代码提交

feat: 岗位会商命令幂等与圆桌后台作业租约调度

See merge request knowledge-base-bj/deerflow-code!22

.claude/launch.json

@@ -0,0 +1,12 @@
+{
+  "version": "0.0.1",
+  "configurations": [
+    {
+      "name": "md-viewer-frontend",
+      "runtimeExecutable": "npx",
+      "runtimeArgs": ["ng", "serve", "--port", "4200"],
+      "port": 4200,
+      "cwd": "F:\\angular\\md-viewer\\frontend"
+    }
+  ]
+}

.claude/settings.json

@@ -0,0 +1,11 @@
+{
+  "permissions": {
+    "allow": [
+      "PowerShell(uv --version)",
+      "PowerShell(netstat -ano)",
+      "PowerShell(Get-NetTCPConnection -LocalPort 8001 -ErrorAction SilentlyContinue)",
+      "PowerShell(Get-Process -Id 20560 -ErrorAction SilentlyContinue | Select-Object Id,ProcessName,Path,StartTime; try { \\(Invoke-WebRequest -Uri \"http://127.0.0.1:8001/health\" -UseBasicParsing -TimeoutSec 5\\).Content } catch { \"health check failed: $_\" })",
+      "Bash(curl -s -X POST -H \"Content-Type: application/json\" -d '{\"username\":\"demo\"}' http://localhost:8001/api/v1/auth/login/username)"
+    ]
+  }
+}

.codex-server-diagnose.py

@@ -0,0 +1,20 @@
+import os
+
+import paramiko
+
+
+client = paramiko.SSHClient()
+client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+client.connect(
+    "119.254.86.251",
+    port=22322,
+    username="root",
+    password=os.environ["TARGET_SSH_PASSWORD"],
+    timeout=15,
+    auth_timeout=15,
+    banner_timeout=15,
+)
+_, stdout, stderr = client.exec_command(os.environ["TARGET_SSH_COMMAND"], timeout=30)
+print(stdout.read().decode(errors="replace"), end="")
+print(stderr.read().decode(errors="replace"), end="")
+client.close()

.dockerignore

@@ -0,0 +1,35 @@
+# Never send source-control history, local dependencies, runtime state, or
+# credentials to the Docker daemon.  The offline images are built from the
+# repository root by deploy/1panel-offline/Dockerfile.*.
+.git
+.runtime
+.history
+tmp
+dist
+
+# Credentials and environment-specific configuration are supplied at runtime
+# through the offline delivery package, never copied into an image layer.
+**/.env
+**/.env.*
+offline-backend-20260512/backend/.deer-flow
+offline-backend-20260512/backend/logs
+offline-backend-20260512/backend/docker-data
+offline-backend-20260512/backend/dist
+offline-backend-20260512/backend/wheelhouse
+offline-backend-20260512/backend/offline-wheels
+offline-backend-20260512/backend/.venv
+offline-backend-20260512/backend/.pytest_cache
+offline-backend-20260512/backend/.ruff_cache
+
+# Reproducibly install frontend dependencies inside the image instead.
+frontend-web/node_modules
+frontend-web/dist
+frontend-web/.vite
+frontend-web/.offline-pack-build
+frontend-web/.offline-extract-test
+frontend-web/node_modules-offline-*.tar.gz
+
+# Editor and operating-system metadata.
+**/__pycache__
+**/*.py[cod]
+**/.DS_Store

.gitignore

@@ -1,15 +1,23 @@
 # Workspace/editor
-.vscode/
-frontend-web/.vscode/
-
+.vscode/*
+!.vscode/launch.json
+!.vscode/tasks.json
+!.vscode/extensions.json
+!.vscode/settings.json
+frontend-web/.vscode/
+node_modules/
 # Claude Code local-only settings (per-user permissions, not shared)
 .claude/settings.local.json
 
 # Local runtime logs and pid files
 .runtime/
+logs/
+offline-backend-20260512/backend/logs/
 
 # Frontend local/runtime artifacts
 frontend-web/.env
+frontend-web/.env.local
+frontend-web/.env.*.local
 frontend-web/node_modules/
 frontend-web/.pnpm-store/
 frontend-web/tsconfig.tsbuildinfo
@@ -24,8 +32,9 @@ frontend-web/src.zip
 frontend-web/src9.zip
 frontend-web/src-v1.zip
 frontend-web/src-*.rar
-
+frontend-web/dist
 # Frontend build artifacts
+frontend-web/dist/
 frontend-web/dist-scheduled-check/
 
 # Offline backend bundles and local deployment artifacts
@@ -47,8 +56,9 @@ offline-backend-20260505/bundle/start_backend.sh
 offline-backend-20260505/bundle/stop_backend.sh
 
 # offline-backend-20260512 runtime artifacts (large files, local config, data)
-offline-backend-20260512/.env.example
-offline-backend-20260512/DEPLOY_BACKEND_OFFLINE_ZH.md
+offline-backend-20260512/.env.example
+offline-backend-20260512/.env
+offline-backend-20260512/DEPLOY_BACKEND_OFFLINE_ZH.md
 offline-backend-20260512/SHA256SUMS
 offline-backend-20260512/config.yaml.example
 offline-backend-20260512/data/
@@ -56,12 +66,14 @@ offline-backend-20260512/deerflow-backend-offline-image-20260505.tar
 offline-backend-20260512/extensions_config.json
 offline-backend-20260512/skills/
 offline-backend-20260512/wheelhouse/
-offline-backend-20260512/backend/.deer-flow/data/*.db
-offline-backend-20260512/backend/.deer-flow/data/*.db-*
-offline-backend-20260512/backend/.deer-flow/*
-offline-backend-20260512/start_backend.sh
-offline-backend-20260512/stop_backend.sh
-offline-backend-20260512/check_backend.sh
+offline-backend-20260512/backend/.deer-flow/data/*.db
+offline-backend-20260512/backend/.deer-flow/data/*.db-*
+offline-backend-20260512/backend/.deer-flow/*
+offline-backend-20260512/backend/.env
+offline-backend-20260512/backend/.env.local
+offline-backend-20260512/start_backend.sh
+offline-backend-20260512/stop_backend.sh
+offline-backend-20260512/check_backend.sh
 
 hermes-agent-main/
 
@@ -72,7 +84,49 @@ offline-backend-20260512/backend/.deer-flow/*
 
 # Per-user skill_evolution overrides — runtime data written by the API
 offline-backend-20260512/backend/skill_evolution.json
-skills/
-hermes-agent-main/
+skills/
+hermes-agent-main/
 .gitignore
-offline-backend-20260512/backend/tests/*
+offline-backend-20260512/backend/tests/*
+!offline-backend-20260512/backend/tests/test_llmwiki_weknora.py
+!offline-backend-20260512/backend/tests/test_health_auth_bypass.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
+deploy
+.history
+
+# Cloned third-party repos (local only)
+git-clone/
+
+# Repo-root offline dependency pack (local only)
+/dist/
+
+# Frontend offline pack working directories
+frontend-web/.offline-pack-build/
+frontend-web/.offline-extract-test/
+frontend-web-node_modules-offline-*.tar.gz
+
+# Local dependency caches and backend scratch archives
+/.pnpm-store/
+/offline-backend-20260512/backend/backend*.zip
+
+.codegraph
+codegraph.mdc
+
+docs/aidev-docs
+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
+
+# Local-only scratch directory (not committed)
+0622/
+
+# Python bytecode cache
+__pycache__/
+
+# misc
+.DS_Store

.vscode/extensions.json

@@ -0,0 +1,6 @@
+{
+  "recommendations": [
+    "ms-python.python",
+    "ms-python.debugpy"
+  ]
+}

.vscode/launch.json

@@ -0,0 +1,66 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "DeerFlow: Backend FastAPI (8001)",
+      "type": "debugpy",
+      "request": "launch",
+      "module": "uvicorn",
+      "args": [
+        "app.gateway.app:app",
+        "--host",
+        "0.0.0.0",
+        "--port",
+        "8001"
+      ],
+      "cwd": "${workspaceFolder}/offline-backend-20260512/backend",
+      "python": "${workspaceFolder}/offline-backend-20260512/backend/.venv/Scripts/python.exe",
+      "envFile": "${workspaceFolder}/offline-backend-20260512/.env",
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}/offline-backend-20260512/backend;${workspaceFolder}/offline-backend-20260512/backend/.deer-flow/python-vendor",
+        "GATEWAY_CORS_ORIGINS": "http://localhost:5174,http://127.0.0.1:5174,http://localhost:8080,http://127.0.0.1:8080",
+        "UV_LINK_MODE": "copy",
+        "WEKNORA_ADMIN_PASSWORD": "1qaz@WSX"
+      },
+      "console": "integratedTerminal",
+      "redirectOutput": true,
+      "justMyCode": false,
+      "subProcess": true
+    },
+    {
+      "name": "DeerFlow: Frontend Vite (5174)",
+      "type": "node-terminal",
+      "request": "launch",
+      "command": "npm.cmd run dev -- --host 0.0.0.0 --port 5174",
+      "cwd": "${workspaceFolder}/frontend-web",
+      "env": {
+        "VITE_BACKEND_BASE_URL": "http://127.0.0.1:8001",
+        "VITE_LANGGRAPH_BASE_URL": "http://127.0.0.1:8001/api"
+      },
+      "serverReadyAction": {
+        "pattern": "Local:\\s+(https?://[^\\s]+)",
+        "uriFormat": "%s",
+        "action": "openExternally"
+      }
+    },
+    {
+      "name": "DeerFlow: Open Frontend in Chrome",
+      "type": "node-terminal",
+      "request": "launch",
+      "preLaunchTask": "DeerFlow: Start Full Stack and Wait",
+      "command": "powershell.exe -NoProfile -ExecutionPolicy Bypass -Command \"Start-Process 'http://127.0.0.1:5174/'\"",
+      "cwd": "${workspaceFolder}"
+    }
+  ],
+  "compounds": [
+    {
+      "name": "DeerFlow: Full Stack (Backend + Frontend)",
+      "preLaunchTask": "DeerFlow: Stop Full Stack",
+      "configurations": [
+        "DeerFlow: Backend FastAPI (8001)",
+        "DeerFlow: Frontend Vite (5174)"
+      ],
+      "stopAll": true
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "python.defaultInterpreterPath": "${workspaceFolder}/offline-backend-20260512/backend/.venv/Scripts/python.exe",
+  "python.terminal.activateEnvironment": true,
+  "typescript.tsdk": "frontend-web/node_modules/typescript/lib",
+  "npm.packageManager": "npm"
+}

.vscode/tasks.json

@@ -0,0 +1,152 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "DeerFlow: Start Full Stack and Wait",
+      "type": "process",
+      "command": "powershell.exe",
+      "args": [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        "${workspaceFolder}/scripts/start-all-and-wait-frontend.ps1"
+      ],
+      "problemMatcher": []
+    },
+    {
+      "label": "DeerFlow: Start Full Stack",
+      "type": "process",
+      "command": "powershell.exe",
+      "args": [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        "${workspaceFolder}/scripts/start-all.ps1"
+      ],
+      "problemMatcher": []
+    },
+    {
+      "label": "DeerFlow: Stop Full Stack",
+      "type": "process",
+      "command": "powershell.exe",
+      "args": [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        "${workspaceFolder}/scripts/stop-all.ps1"
+      ],
+      "problemMatcher": []
+    },
+    {
+      "label": "DeerFlow: Status",
+      "type": "process",
+      "command": "powershell.exe",
+      "args": [
+        "-NoProfile",
+        "-ExecutionPolicy",
+        "Bypass",
+        "-File",
+        "${workspaceFolder}/scripts/status.ps1"
+      ],
+      "problemMatcher": []
+    },
+    {
+      "label": "DeerFlow: Check Local Dev Environment",
+      "type": "shell",
+      "command": "$backendPython = '${workspaceFolder}\\offline-backend-20260512\\backend\\.venv\\Scripts\\python.exe'; if (-not (Test-Path -LiteralPath $backendPython)) { throw 'Backend virtual environment is missing. Run uv sync in offline-backend-20260512/backend first.' }; & $backendPython -c \"import uvicorn; print('Backend Python OK')\"; npm --prefix '${workspaceFolder}\\frontend-web' exec vite -- --version",
+      "options": {
+        "shell": {
+          "executable": "powershell.exe",
+          "args": [
+            "-NoProfile",
+            "-ExecutionPolicy",
+            "Bypass",
+            "-Command"
+          ]
+        }
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "DeerFlow: Install Frontend Dependencies",
+      "type": "process",
+      "command": "npm",
+      "args": [
+        "ci",
+        "--no-audit",
+        "--no-fund"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}/frontend-web"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "DeerFlow: Frontend Typecheck",
+      "type": "process",
+      "command": "npm",
+      "args": [
+        "run",
+        "typecheck"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}/frontend-web"
+      },
+      "problemMatcher": "$tsc"
+    },
+    {
+      "label": "DeerFlow: Frontend Build",
+      "type": "process",
+      "command": "npm",
+      "args": [
+        "run",
+        "build"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}/frontend-web"
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "DeerFlow: Backend Tests",
+      "type": "process",
+      "command": "${workspaceFolder}/offline-backend-20260512/backend/.venv/Scripts/python.exe",
+      "args": [
+        "-m",
+        "pytest",
+        "tests/",
+        "-v"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}/offline-backend-20260512/backend",
+        "env": {
+          "PYTHONPATH": ".",
+          "WEKNORA_ADMIN_PASSWORD": "1qaz@WSX"
+        }
+      },
+      "problemMatcher": []
+    },
+    {
+      "label": "DeerFlow: WeKnora Backend Tests",
+      "type": "process",
+      "command": "${workspaceFolder}/offline-backend-20260512/backend/.venv/Scripts/python.exe",
+      "args": [
+        "-m",
+        "pytest",
+        "tests/test_llmwiki_weknora.py",
+        "-v"
+      ],
+      "options": {
+        "cwd": "${workspaceFolder}/offline-backend-20260512/backend",
+        "env": {
+          "PYTHONPATH": ".",
+          "WEKNORA_ADMIN_PASSWORD": "1qaz@WSX"
+        }
+      },
+      "problemMatcher": []
+    }
+  ]
+}

.zcode/plans/plan-sess_bc89c1c7-ec32-43b9-886f-70fa2ae83a13.md

@@ -0,0 +1,61 @@
+# 深度研究第三轮：检索稳定性修复 + 参考文献确定性 + 页面对齐 AI 写作改造
+
+## A. 两个 bug 的排查结论与修复
+
+### A1. 第二次检索「网络波动」——确认是真问题（DDG 限流 + 错误语义混淆 + 零重试）
+
+**排查结论**（用户判断"确实是网络波动"基本正确，但代码层面放大了它）：
+- 「网络波动」文案不存在于任何代码中——是收集员 LLM 看到 `{"error": "No results found"}` 信封后自己编的解释
+- 真实根因：DDG html 端点对同 IP 快速连续请求限流（403/429 挑战页）→ `DDGSException` → `ddg_search/tools.py::_search_text` 把异常吞成 `[]` → 上层把「被限流」和「真没结果」混成同一个错误信封；工具层完全没有重试
+
+**修复**（`packages/harness/deerflow/community/ddg_search/tools.py`）：
+1. `_search_text` 对异常加 2 次重试 + 指数退避（约 1.5s / 3s + 抖动）
+2. 错误信封区分场景：真无结果 → `no results`；多次尝试仍失败 → `web search failed after N attempts (rate limited or network), 换一组检索词稍后重试`——让模型不再瞎猜「网络波动」
+3. 收集员 SOUL.md 行为准则加一条（同步改种子资产 + 已安装副本 `.deer-flow/agents/deep-research-collector/`）：搜索返回 error 信封时先换检索词重试一轮，而不是直接告知用户网络异常
+
+### A2. 参考文献缺失——代码确有隐患（当前是模型自发行为，时有时无）
+
+**排查结论**：后端没有任何「参考来源」追加逻辑；四个 runner 的报告 prompt 只要求内联 `[N]` 引用。出现过的参考列表是模型看到上下文头 `[N] 标题（URL）` 后**自发**补写的——弱模型下不可靠，与"信息够不够"无必然关系。
+
+**修复**（prompt 指示 + 确定性兜底双保险）：
+1. 四个 runner（basic / detailed / deep / multi_agent）的报告 prompt 各加一条：报告最后附「## 参考来源」，按 `[N] 标题. URL` 列出正文实际引用过的来源
+2. `basic.py` 新增共享函数 `ensure_reference_section(report, context_list, materials)`：报告缺少参考小节时，解析正文引用的 `[N]` 编号，按压缩上下文顺序生成编号列表追加（无编号时列全部来源，封顶 20 条；已有参考小节则不重复追加）。在各 runner 最终 `write_text("report.md", ...)` 前调用（约 7 个调用点，跳过零材料 fallback）
+3. 新增测试 `tests/test_deep_research_references.py`：helper 单测（正常追加/编号映射/不重复追加/无 URL 来源）+ runner 集成断言
+
+## B. 页面改造（核心需求）：左列复用 AI 写作对话形态，右列改真沙箱
+
+### B1. 左列 = AI 写作式对话收集面板（仿 WritingSetupChat）
+
+- **空状态欢迎屏**（无消息时隐藏头部，展示欢迎卡片，WritingWelcome 式）+ 有消息后 `MessageList`（沿用现有绑 collector 线程的接线）+ 首 token 前「正在整理…」占位条
+- **输入框换成白卡片 PromptInput 套件**（与 AI 写作完全同款组件）：卡片内一行「当前对话模型」Select（沿用 ModelNameSelect）+ 高级配置入口；下方 PromptInputTextarea + PromptInputFooter + PromptInputSubmit（`status` ready/streaming，流式中变停止按钮）。经典模式入口保留在高级配置对话框
+- **配置卡片进对话流**（对标 AI 写作「识别出意图后出现表单」）：
+  - `message-list.tsx` 最小扩展（约 15 行）：新增分组 `assistant:research-approval`（识别 `additional_kwargs.setup_research_approval`）+ 可选 prop `researchApprovalSlot?: ReactNode`；不传 slot 或无该载荷时零行为变化——普通对话/AI 写作完全不受影响
+  - workbench：收集回合结束（awaiting_report，即"意图识别完成"）时向 `displayThread` 尾部注入一条虚拟 ai 消息（WritingSetupChat 的 displayThread 同款手法），slot 传现有 `ReportConfigCard` → 卡片作为助手下一轮出现在对话流里
+- 写作进度卡、完成卡、摘要气泡、追问列表保留在列表下方卡片区（报告正文移到右侧沙箱）
+
+### B2. 右列 = 工作区真沙箱（Step2SandboxLayout 的 stub 线程模式）
+
+- 新建 `deep-research/ResearchSandboxPanel.tsx`（约 100 行，含关闭/重开）+ `useReportSandbox.ts` hook（仿 `useStep3Report` 的 stub 机制）：
+  - threadStub：`messages = [{type:'ai', tool_calls:[{name:'write_file', args:{path:'/mnt/user-data/outputs/report.md', content: <流式报告>}}]}]`，`isLoading = job 运行中 && phase !== 'summarizing'`
+  - `report_delta` 首帧 → `openArtifact(write-file: 虚拟URL)` 自动展开右栏；`run.report` 每帧 upsert stub（带防抹空守卫）；刷新/切换会话用 `session.reportMarkdown` 重建
+  - `ArtifactFileDetail` 自带能力全部免费获得：**流式期 code 视图自动滚底 → 报告写完 isLoading 翻 false 自动切 preview + 脉冲提示**（正是「生成完直接切预览」）、Streamdown 渲染的 Markdown（比现在的好看）、另存 Word/复制/下载、默认走展示层脱敏
+- 布局：ResizablePanelGroup chat 60 / sandbox 40（对齐 ChatBox/圆桌），沙箱可关闭、头部按钮重开
+- **删除自定义 `ResearchSandbox` 组件**；legacy 会话与经典模式共用同一右栏（`run.report` 数据源相同，行为一致）
+- 已知小限制（可接受）：报告配图模式下沙箱内图片可能无法经 artifacts API 解析（配图默认关闭；真需要时后续把产物落 thread artifacts）
+
+### B3. 验证
+
+- 后端：`PYTHONPATH=. uv run --no-sync pytest tests/ -k deep_research -q --ignore=tests/test_notification_templates.py` 全绿 + ruff；改完配置/SOUL 后 touch 触发 dev 服务重载
+- 前端：`pnpm typecheck` 零新增错误（基线 51）
+- 手动走查：连续两次检索不再误报、弱模型报告末尾必带参考来源、页面全流程（欢迎屏 → 对话收集 → 流内配置卡 → 沙箱流式 → 自动预览 → 摘要/追问）
+
+## 涉及文件
+
+**后端**：`community/ddg_search/tools.py`、`deep_research/runners/{basic,detailed,deep,multi_agent}.py`、收集员 SOUL.md（种子 + 已安装副本）、`tests/test_deep_research_references.py`（新）
+**前端**：`components/workspace/messages/message-list.tsx`（可选 slot 分组）、`pages/deep-research/DeepResearchWorkbench.tsx`（大改）、`pages/deep-research/ResearchSandboxPanel.tsx`（新）、`pages/deep-research/useReportSandbox.ts`（新）
+
+## 明确不动
+
+- AI 写作 / 普通对话现有组件行为（message-list.tsx 仅加可选分组，缺省零变化）
+- 报告写作管线的写作逻辑本身（prompt 加一条要求 + 末尾确定性追加参考小节，均为附加式）
+- 深度研究后端会话/任务/事件模型（本轮不动）

AGENTS.md

@@ -0,0 +1,104 @@
+# AGENTS.md
+
+This file provides guidance to Codex (Codex.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a customized offline deployment of **DeerFlow** — a LangGraph-based AI super agent platform. The repo contains two sub-projects:
+
+- `offline-backend-20260512/backend/` — Python backend (FastAPI Gateway + LangGraph agent runtime)
+- `frontend-web/` — Vite + React 19 frontend (TypeScript, pnpm)
+
+Managed together via shell scripts in `scripts/`.
+
+## Commands
+
+### Full Application (from repo root)
+
+```bash
+./scripts/start-all.sh    # Start backend + frontend as background daemons
+./scripts/stop-all.sh     # Stop both
+./scripts/restart-all.sh  # Restart both
+./scripts/status.sh       # Check running status
+```
+
+Logs and PID files are written to `.runtime/logs/` and `.runtime/pids/`.
+
+### Backend Only (from `offline-backend-20260512/backend/`)
+
+```bash
+make install    # Install Python dependencies (uv)
+make dev        # Run Gateway API with hot-reload on port 8001
+make gateway    # Run Gateway API without reload
+make test       # Run all tests: PYTHONPATH=. uv run pytest tests/ -v
+make lint       # Lint with ruff
+make format     # Format with ruff
+```
+
+Run a single test file:
+```bash
+PYTHONPATH=. uv run pytest tests/test_<feature>.py -v
+```
+
+### Frontend Only (from `frontend-web/`)
+
+```bash
+pnpm install    # Install dependencies
+pnpm dev        # Start Vite dev server on port 5174
+pnpm build      # Production build
+pnpm typecheck  # TypeScript type checking (tsc --noEmit)
+```
+
+## Service Ports
+
+| Service | Port | Notes |
+|---------|------|-------|
+| Backend (Gateway API) | 8001 | FastAPI + LangGraph runtime |
+| Frontend (Vite) | 5174 | React SPA |
+
+Frontend connects to backend via env vars `VITE_BACKEND_BASE_URL` and `VITE_LANGGRAPH_BASE_URL` (injected by `scripts/start-frontend.sh`).
+
+## Architecture
+
+### Backend
+
+The backend (`offline-backend-20260512/backend/`) is split into two layers:
+
+- **`packages/harness/deerflow/`** — publishable agent framework (`deerflow.*` imports): LangGraph lead agent, middleware chain, sandbox, tools, MCP, memory, models, skills. **Never imports from `app.*`.**
+- **`app/`** — application layer (`app.*` imports): FastAPI Gateway routers, IM channel integrations (Feishu, Slack, Telegram, DingTalk).
+
+The **Lead Agent** (`deerflow/agents/lead_agent/`) is the single LangGraph graph entry point. It wraps a middleware chain (~18 middlewares assembled in strict order) around LLM calls, handling: thread isolation, sandbox lifecycle, uploads, memory, plan mode, vision, subagent delegation, and loop detection.
+
+**Middleware order matters** — middlewares are appended in a fixed sequence; `ClarificationMiddleware` must always be last. See `offline-backend-20260512/backend/AGENTS.md` for the full ordered list.
+
+**Harness → App import firewall** is enforced by `tests/test_harness_boundary.py` (runs in CI).
+
+### Frontend
+
+The frontend (`frontend-web/`) is a React 19 + Vite SPA:
+
+- **Routing**: React Router v7; top-level routes in `src/pages/PageRoutes.tsx`, workspace sub-routes in `src/pages/WorkspaceRoutes.tsx`
+- **Pages**: `ChatPage` (thread chat), `AgentChatPage` (custom agent chat), `AgentsPage`/`NewAgentPage` (agent management), `ScheduledTasksPage`/`ScheduledTaskRunDetailPage` (scheduled tasks), `LightAppManagementPage`/`LightAppListPage`/`LightAppIframeView` (轻应用中心 — register/list/embed mini-apps)
+- **AI 写作·对话版（对话驱动写作台）**: a **parallel new entry** beside the classic AI-writing page (classic page/routes untouched) — route `/page/canvas/ai-writing-chat`, sidebar 「问答管理 → 课题研究(对话版)」. Page `open-canvas/pages/AIWritingChatPage.tsx` reuses the engine (`AIWritingContext` + `useStream` + `AIWritingDraftPanel`); **idle keeps the classic setup layout** (`WritingSetupChat` + collapsible form) and switches to the chat workbench once writing starts; left panel `components/ai-writing-chat/WritingChatPanel.tsx` = **unified chronological feed** (`ChatFlowTimeline.tsx`, chat bubbles anchor-interleaved into the progress timeline so triggered events render below the user's message) + button-only intervention cards (`ChatInterventionCards.tsx`, inline textareas removed) + bottom unified smart composer. Intent resolution: frontend fast path + `POST /api/ai-writing/sessions/{id}/intent` → `deerflow/agents/ai_writing/intent_router.py` (per-pause action whitelist, high-cost confidence gates, payload cleaning); supports QA bypass, clarify follow-ups, control intents, and material-stage auto re-search + pending-intent resume. Tests `tests/test_ai_writing_intent.py`; plan doc `frontend-web/docs/ai-writing-对话驱动写作台-实现方案.md`.
+- **轻应用中心 (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).
+- **舆情分析智能体（前端虚拟智能体）**: 智能体管理页新增「舆情分析」类型 tab，固定一张虚拟智能体卡片（名称/简介可编辑，存 localStorage）。对话页 `pages/SentimentAgentChatPage.tsx`（路由 `agents/sentiment-analysis/chats/:thread_id`）复用普通问答布局 + `MessageList`，**输入框只有发送按钮**；问答直连外部 AG-UI 网关（POST SSE），不经过 LangGraph，会话仅存 sessionStorage。接口地址 + Basic Auth 在 `runtime-config.js` 配置（`VITE_SENTIMENT_AGENT_API_URL` / `_AUTH_USERNAME` / `_AUTH_PASSWORD`），核心模块 `src/core/sentiment-agent/`。
+- **敏感词管理 (Sensitive Word Management)**: configures the **展示层脱敏映射** (原始词 → 替换词). **Gated on the username `lqq`** (not the admin role) — `getAccountDisplayName().toLowerCase() === "lqq"` (username = email `@` prefix, else `user_id`, same as the profile page); the dropdown entry, the route guard, and the page-level guard all use this check. `src/lib/desensitize.ts` ships a frozen seed map `SEED_DESENSITIZE_MAP` (the deployment seed) plus a live mutable `DESENSITIZE_MAP` (initialized from the seed so `desensitize()` works before any fetch). `DesensitizeWordsLoader` (mounted in `App.tsx` `AppProviders`) fetches `/api/sensitive-words` on startup and, if non-empty, calls `replaceDesensitizeMap(...)` to make the backend config the source of truth (empty/failed → keep seed). Page `SensitiveWordsPage.tsx` (route `/page/strategy/admin/sensitive-words`, opened from the 「敏感词管理」 item in the **bottom-left settings dropdown** of `components/page-sidebar.tsx`, present in **both** full + collapsed sidebar modes) lists/adds/edits/启停/deletes words and saves the **whole set atomically** (replace-all); a 「导入种子词」 button merges any missing `SEED_DESENSITIZE_MAP` entries into the editor. Client + hooks in `strategy-components/api/sensitive-words.ts` (`wordsToMap` folds enabled rows into the runtime map). Backend: `/api/sensitive-words` (global/shared; open read, write allowed for admin **or** the `lqq` account), mirroring 菜单管理's store shape. **侧边栏 + 导航栏 menu labels are desensitized** at the data source: `useSidebarMenuItems`/`useActiveThirdLevel` (`core/page-layout/use-sidebar-menu.ts`) map every node's `label` through a desensitizer built **directly from the `/api/sensitive-words` query** (`makeDesensitizer(wordsToMap(words))`, falling back to the global seed `desensitize` while empty) — this sidesteps the `replaceDesensitizeMap` effect-timing race. Only `label` is rewritten; `path`/`id`/`icon` are untouched so routing/highlight are unaffected. All nav surfaces (`page-sidebar.tsx`, `page-sidebar-dark.tsx`, `page-sidebar-v1.tsx`, `strategy-components/Header.tsx`, `PageRoutes.tsx`) consume this hook and are covered; `MenuManagementPage` uses the raw tree so admins still edit real labels.
+- **技能地址管理 (Skill Address Management, admin-only)**: 扫描运行中的技能（`skills/{public,custom}` 下所有 `.md`/`.py`）里的 **http(s) URL 与 IP/IP:端口**，按唯一地址聚合全部出现位置（跨 .md/.py），支持**批量替换**（如把 UAT 地址一次性改成生产）。主体抽成可复用组件 `SkillAddressesPanel`（`pages/SkillAddressesPage.tsx` 导出，默认导出 `SkillAddressesPage` 仍保留旧路由 `/page/strategy/admin/skill-addresses` 作直链回退），**作为「技能地址管理」标签页嵌入管理员「技能管理」页 `pages/AdminSkillsPage.tsx`**（该页加 Tabs：「技能列表」+「技能地址管理」；入口在「设置和更多」下拉的「技能管理」`workspace-nav-menu.tsx` → `/page/workspace/admin/skills`，不再单列于 `components/page-sidebar.tsx` 左下角设置下拉）：打开自动扫描并带**进度条**（扫描逐技能 / 应用逐文件 X/N，应对 150+ 技能），URL/IP 类型过滤 + 搜索 + 「片段批量套用」（如所有 `uat.4.cn` → `prod.4.cn`）、每地址「替换为」输入框（可展开看 `file:line` 片段）、内联**预览**、**应用**、**多关键词检索**（空格分隔全部命中），以及**修改记录**面板——每次应用生成一条记录（显示时间/改了哪些地址 from→to/文件数/处数），可**针对单次记录回退**（二次确认）。client + NDJSON 流式解析在 `strategy-components/api/skill-addresses.ts`。后端 `/api/skill-addresses`（**仅管理员**）：所有文件 IO 走 `asyncio.to_thread` 不阻塞事件循环；`GET /scan`(+`/scan/stream`)、`POST /preview`、`POST /apply`(+`/apply/stream`)、`GET /backups`、`POST /rollback/{id}`；**子串安全替换**（基于 token span，不会误伤子串）、`expected_total` 乐观锁（409）、写前自动磁盘备份到 `{skills_root}/.address-edits/`（同时写一份 `{id}.manifest.json` 记录本次替换明细，供修改记录展示）、应用后刷新技能系统提示缓存。纯引擎 `deerflow/skills/address_scan.py`，router `app/gateway/routers/skill_addresses.py`，tests `tests/test_skill_addresses.py`。范围仅运行中技能，不动 `deploy/minimal/skills/`。
+- **按钮管理 (Task Button Management, admin-only)**: configures the **可配置跳转按钮** rendered in the left task panel of the task deep-link workspaces (rwfx / 3qfx / xdfx, see `TaskFxWorkspace`). Each button = `{business, label, linkType, target, appendTaskId, idParam, idKind, enabled, sortOrder}`; `linkType` is `url` (外链 `window.open`, optional append of `?{idParam}={id}` — **`idParam` is the editable query-param name**, e.g. `id`/`task_id`), `business` (内部切换到另一业务, reuses `resolveTaskDeeplinkTarget`, always task id), or `purpose` (弹出当前任务的「任务目的」表格 via the shared `TaskPurposeDialog`, no target — configurable for any page incl. xdfx). **`idKind` (`task`/`action`) only matters for xdfx**: its deep-link `?taskId=` is an 行动id and the 任务id is resolved at login (`fetchTaskIdFromAction`) — `TaskContext` now also stashes the raw `actionId`, so a url button can append either (default `task`). Page `TaskButtonsPage.tsx` (route `/page/strategy/admin/task-buttons`, **admin-gated**, entry「按钮管理」in the bottom-left settings dropdown of `components/page-sidebar.tsx`, both full + collapsed modes) has per-business tabs, edits name/type/target/启停/排序/增删, saves the **whole set atomically** (replace-all), plus 「导入默认」 to merge code-seed defaults. **Seed/fallback** (like 敏感词管理): only when the whole table is empty (fresh deploy, never saved) do the workspace + page fall back to `defaultTaskButtons(cfg)` — rwfx's url buttons (编辑/下一步/3q详情) built from the **live** `/api/public/config/task-deeplink` plus cross-business switch buttons for **all three** businesses (each switches to the other two — rwfx→三情/行动, 3qfx→任务/行动, xdfx→任务/三情). Once saved, the store is the sole source of truth. The old hardcoded jump buttons were migrated out: `TaskFxWorkspace` no longer hardcodes 切换到三情分析, `TaskActionsPanel` keeps only the non-jump 清除记录, and `TaskPurposePanel` dropped its 3q详情 button (now configurable) **and defaults the 目的树 table to collapsed** (chevron toggle). Helpers `core/auth/task-buttons.ts` (`TaskButton`, `defaultTaskButtons`, `resolveTaskButtons`, `buttonsForBusiness`, `runTaskButton`), client+hooks `strategy-components/api/task-buttons.ts`. Backend: `/api/task-buttons` (global/shared; open read, admin replace-all), store `deerflow.persistence.task_buttons` (table `task_buttons`, auto-created by `create_all`), wired `app.state.task_button_store`. Tests: `tests/test_task_buttons.py`.
+- **State**: TanStack Query for server state, context providers (`SubtasksProvider`, `ArtifactsProvider`, `PromptInputProvider`) scoped to `WorkspaceRoutes`
+- **LLM streaming**: `@langchain/langgraph-sdk` streams messages from the backend via SSE
+- **UI**: Radix UI primitives + TailwindCSS v4 + shadcn-style components in `src/components/ui/`
+- **Shims**: `src/shims/` provides `next/link` and `next/navigation` polyfills (original code was Next.js)
+- **Login URL params** (`LoginPage.tsx`, frontend-only — the backend never sees these): besides the auth params (`ticket`/`userId`/`env`/`theme`/`yUserId`/`token`/`access_token`/`authToken`/`password`), the page supports a **task deep-link** via `?taskId=&goPath=`. After login it calls the consumer API `GET {VITE_AIPI_CONSUMER_URL}/taskAnalyseSearch/cop-task-detail?taskId=` (header `Authorization: Bearer admin`, auto-injected by `utils/request.ts`), stashes the full `data` (`id/overview/taskDirection/taskName/taskContent`) into `sessionStorage["login.copTaskDetail"]`, then routes by `goPath`: base codes `3qfx`/`rwfx`/`xdfx` → that business's configured **single agent** Q&A inside a **任务工作区** (resolved via `/api/business-mapping`; `resolveTaskDeeplinkTarget` calls `persistTaskContext({taskId, agentId, openingText})` and navigates to the `…/chats` **index**, which opens the latest task conversation or 新建 — a 1:N task↔对话 workspace, NOT `pendingAgentMessage`); the `-A` suffix (`3qfx-A`/…) → **multi-agent roundtable** with `roundtablePrefill.businessCode` so the page auto-selects the configured 业务链条. **xdfx's deep-link `?taskId=` is actually an 行动id, not a 任务id** — `resolveDeeplinkTaskId(goPath, rawId)` (called in `LoginPage` before everything) detects `xdfx`/`xdfx-A` and resolves it via `GET {action_detail_url}/{actionId}` → `data.taskId` (`fetchTaskIdFromAction`; `action_test`+`mock.action_detail` for offline testing); the resolved 任务id then drives `cop-task-detail`, the purpose tree, and the 1:N binding (other businesses pass the id through unchanged). **xdfx additionally partitions its chat records by 行动id (action_id), NOT by task_id**: `resolveTaskDeeplinkTarget` sets `partitionByAction:true` + keeps the raw action_id as `TaskContext.actionId`, so new threads are tagged `metadata.{taskId,actionId}` (taskId kept only to preserve the backend「任务深链对话全局共享」semantics, which keys off `metadata.taskId`) and the conversation list filters by `actionId` (+`agent_id`) — different actions of the same task get separate lists. xdfx's first-question opening text also appends `行动id（action_id）为…` (see `buildOpeningText` / `taskThreadMetadata`). goPath→businessCode: `3qfx`→`3Q`, `rwfx`→`6BF`, `xdfx`→`7BF`. The roundtable target also threads the URL `taskId` into `roundtablePrefill.taskId` (`resolveTaskDeeplinkTarget(goPath, detail, taskId)`), which turns on two taskId-scoped behaviors: (1) **separate, unpartitioned per-task storage** — taskId 会商聊天记录 live in their **own** store/table (`roundtable_task_drafts`), keyed **only by `task_id`** (one taskId = many records, shared across users, **no user 分权** at all; `created_by` is audit-only), kept entirely out of the per-user personal store (`roundtable_drafts`, now strictly per-user) so the two never mix. Backend router `/api/roundtable-task-drafts` (`GET /by-task/{id}` + `/by-task/{id}/latest`, `POST`, `GET/PUT/DELETE /{id}` — all user-agnostic); frontend client `roundtable-planning/api/task-drafts.ts`, and `useDraftPersistence`/`useRoundtableDrafts` route **all** CRUD to it when a `taskId` is present (else the personal `drafts.ts`). The matching **background jobs** are shared by task too: `roundtable_jobs.task_id` marks a task job; reads/dedup/stream/resume/cancel pass `?task_id=` so any user opening the task sees the same running 研讨 (progress/flowchart), and the executor writes the final report back to the task-draft store. Existing rows are moved over by `scripts/migrate_roundtable_task_drafts.py` (migration `20260618_01`). The history dropdown filters to the task and 新建 keeps the binding; (2) **Step-3 auto structured output** — after the `roundtable-summary` agent writes the Markdown report it automatically runs a second round emitting a `flow-json` flowchart (`useStep3Summary` `autoFlow`+`chainLevels`), whose hierarchy follows the business chain's stage goals (任务 → 目的 → 行为体 → …; coordinatorPrompt-specified hierarchy wins) and whose nodes never carry 阶段编号/阶段名 (the prior bug). **Both targets render embedded under the 任务管理 layout** — nested routes under `task-management/<business-path>/{roundtable,agent/:agent_id/chats}` in `StrategyRoutes.tsx` (`<business-path>` = `plan-task-sentiment` / `plan-task/plan-task-fx` / `plan-task/plan-task-action`, matching the COH中任务 menu paths in `sidebar-menu.ts`) so the global sidebar keeps 任务管理 → COH中任务 → the matching business highlighted. **All three single-agent businesses share `TaskFxWorkspace`** (`task-components/TaskFxWorkspace.tsx`): left = a「当前任务」card (`readCopTaskDetail()` 任务名称 + 简介, desensitized, 留存 above 新建对话) + per-task 1:N conversation list (`useTaskThreads(taskId, agentId, actionId?)` — filtered by **both** `metadata.taskId` AND `metadata.agent_id` so the three businesses' conversations staLine truncated
+- **iframe 嵌入模式 (外部系统用 iframe 套用深链问答/会商)** — 三个**按标签页**开关，全部由深链 URL 参数开启、存进同一份 `sessionStorage` 会话（`embed.session`，键名常量在 `core/embed/embed-session.ts`），跨登录跳转/刷新/页内导航存活，**绝不跨标签污染**同浏览器另开的正常系统页。核心隔离手法：用 `sessionStorage`（按标签页/浏览上下文隔离，iframe 即便同源也有独立一份）而非 `localStorage`（跨标签共享）。开关：(1) **`?embed=1`（可带 `&theme=`）** — 去全局 chrome（`PageLayout` 的 `pageSidebarAllowed && !isEmbedActive()` → 隐藏 Header + PageSidebar）+ 按外部主题色**强制**明/暗：走 next-themes 的 `forcedTheme`（`App.tsx` `AppProviders` 调 `resolveForcedEmbedTheme`，**不写** localStorage `strategy-theme`），离散映射 `dark-blue`/`dark`→深、其余→浅；嵌入侧**绝不**调 `setTheme`/`persistSidebarEnabled`（那俩落 localStorage 跨标签污染，`LoginPage` 据 `readEmbedParam` 跳过）。(2) **`?hideJump=1`** — 隐藏深链底部「快捷跳转」栏 `TaskJumpBar` 的两部分（底部「下一步」等按钮 + 右侧垂直居中悬浮菜单），单智能体问答 + 会商共用该栏，`isJumpBarHidden()` 为真时整条 `return null`。(3) **登录用户隔离** — 嵌入态下鉴权/身份键（`deerflow.auth` token、`userInfo`、`login.*`、`tools_token`、maxkey/userDetail token）全部经 `core/auth/scoped-storage.ts` 的 `authStorage()`（嵌入→sessionStorage / 正常→localStorage）读写，使 iframe 里登录的用户与正常登录用户**完全隔离**、互不覆盖；所有 token 读取都过 `getStoredAuth()`/`getAuthorizationHeaderValue()`（API 客户端 `core/api/*` 全走这俩），改中心函数即让全体调用方自动隔离；跨标签账号变更监听 `AuthSyncWatcher`（`core/auth/sync.tsx`）在嵌入态禁用。嵌入会话在 `main.tsx` 渲染前 `syncEmbedSessionFromCurrentUrl()` 同步启用（早于任何鉴权写入，避免首帧 effect 顺序漏写 localStorage）；`AppProviders` 的 effect 再按 SPA 导航同步。`embed=0`/`hideJump=0` 可显式关闭。正常（非嵌入）标签页所有 `isXxx()` 恒 false，行为**零变化**。第三个开关 `?isolate=1`（**独立登录会话**）把同一套**登录用户隔离**单独提供给**普通（带 chrome）标签页**——只切换鉴权存储、不去 chrome / 不强制主题 / 不动跳转栏：`authStorage()` 的条件从「仅嵌入」放宽为 `isEmbedActive() || isIsolatedSession()`，`AuthSyncWatcher` 的跨标签监听对嵌入态**或**独立态都即时忽略（handler 内实时判，运行时开关也即刻生效）。除 URL 参数外，**设置 → 外观 →「登录会话」** 有一个 Switch「独立登录会话（本标签页）」运行时切换（`setIsolatedSession`，`appearance-settings-page.tsx`）：**开启时先 `migrateAuthToSession()`**（`scoped-storage.ts`，把 localStorage 的受保护键 `deerflow.auth`/`userInfo`/`userId`/`tools_token` + `login.*` 前缀快照搬进 sessionStorage）再翻标志，故无感不登出；此后本标签页登录态独立——别处登录/换号影响不到它，它换号也影响不到别人，但关掉该标签即结束（需重登）。开启给 toast 提示。
+
+### Configuration
+
+Backend config lives in `offline-backend-20260512/backend/config.yaml`. Values starting with `$` resolve as environment variables (e.g., `$OPENAI_API_KEY`). MCP servers and skills are configured in `extensions_config.json` in the same directory.
+
+## Detailed Backend Reference
+
+The backend has its own comprehensive documentation at:
+- `offline-backend-20260512/backend/AGENTS.md` — architecture, middleware chain, all API routes, config schema, sandbox/memory/subagent systems
+- `offline-backend-20260512/backend/README.md` — setup guide, technology stack

CLAUDE.md

@@ -78,11 +78,24 @@ The **Lead Agent** (`deerflow/agents/lead_agent/`) is the single LangGraph graph
 The frontend (`frontend-web/`) is a React 19 + Vite SPA:
 
 - **Routing**: React Router v7; top-level routes in `src/pages/PageRoutes.tsx`, workspace sub-routes in `src/pages/WorkspaceRoutes.tsx`
-- **Pages**: `ChatPage` (thread chat), `AgentChatPage` (custom agent chat), `AgentsPage`/`NewAgentPage` (agent management), `ScheduledTasksPage`/`ScheduledTaskRunDetailPage` (scheduled tasks)
+- **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`.
+- **轻应用中心 (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).
+- **白名单管理 (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`.
+- **敏感词管理 (Sensitive Word Management)**: configures the **展示层脱敏映射** (原始词 → 替换词). **Gated on the username `lqq`** (not the admin role) — `getAccountDisplayName().toLowerCase() === "lqq"` (username = email `@` prefix, else `user_id`, same as the profile page); the dropdown entry, the route guard, and the page-level guard all use this check. `src/lib/desensitize.ts` ships a frozen seed map `SEED_DESENSITIZE_MAP` (the deployment seed) plus a live mutable `DESENSITIZE_MAP` (initialized from the seed so `desensitize()` works before any fetch). `DesensitizeWordsLoader` (mounted in `App.tsx` `AppProviders`) fetches `/api/sensitive-words` on startup and, if non-empty, calls `replaceDesensitizeMap(...)` to make the backend config the source of truth (empty/failed → keep seed). Page `SensitiveWordsPage.tsx` (route `/page/strategy/admin/sensitive-words`, opened from the 「敏感词管理」 item in the **bottom-left settings dropdown** of `components/page-sidebar.tsx`, present in **both** full + collapsed sidebar modes) lists/adds/edits/启停/deletes words and saves the **whole set atomically** (replace-all); a 「导入种子词」 button merges any missing `SEED_DESENSITIZE_MAP` entries into the editor. Client + hooks in `strategy-components/api/sensitive-words.ts` (`wordsToMap` folds enabled rows into the runtime map). Backend: `/api/sensitive-words` (global/shared; open read, write allowed for admin **or** the `lqq` account), mirroring 菜单管理's store shape. **侧边栏 + 导航栏 menu labels are desensitized** at the data source: `useSidebarMenuItems`/`useActiveThirdLevel` (`core/page-layout/use-sidebar-menu.ts`) map every node's `label` through a desensitizer built **directly from the `/api/sensitive-words` query** (`makeDesensitizer(wordsToMap(words))`, falling back to the global seed `desensitize` while empty) — this sidesteps the `replaceDesensitizeMap` effect-timing race. Only `label` is rewritten; `path`/`id`/`icon` are untouched so routing/highlight are unaffected. All nav surfaces (`page-sidebar.tsx`, `page-sidebar-dark.tsx`, `page-sidebar-v1.tsx`, `strategy-components/Header.tsx`, `PageRoutes.tsx`) consume this hook and are covered; `MenuManagementPage` uses the raw tree so admins still edit real labels.
+- **技能地址管理 (Skill Address Management, admin-only)**: 扫描运行中的技能（`skills/{public,custom}` 下所有 `.md`/`.py`）里的 **http(s) URL 与 IP/IP:端口**，按唯一地址聚合全部出现位置（跨 .md/.py），支持**批量替换**（如把 UAT 地址一次性改成生产）。主体抽成可复用组件 `SkillAddressesPanel`（`pages/SkillAddressesPage.tsx` 导出，默认导出 `SkillAddressesPage` 仍保留旧路由 `/page/strategy/admin/skill-addresses` 作直链回退），**作为「技能地址管理」标签页嵌入管理员「技能管理」页 `pages/AdminSkillsPage.tsx`**（该页加 Tabs：「技能列表」+「技能地址管理」；入口在「设置和更多」下拉的「技能管理」`workspace-nav-menu.tsx` → `/page/workspace/admin/skills`，不再单列于 `components/page-sidebar.tsx` 左下角设置下拉）：打开自动扫描并带**进度条**（扫描逐技能 / 应用逐文件 X/N，应对 150+ 技能），URL/IP 类型过滤 + 搜索 + 「片段批量套用」（如所有 `uat.4.cn` → `prod.4.cn`）、每地址「替换为」输入框（可展开看 `file:line` 片段）、内联**预览**、**应用**、**多关键词检索**（空格分隔全部命中），以及**修改记录**面板——每次应用生成一条记录（显示时间/改了哪些地址 from→to/文件数/处数），可**针对单次记录回退**（二次确认）。client + NDJSON 流式解析在 `strategy-components/api/skill-addresses.ts`。后端 `/api/skill-addresses`（**仅管理员**）：所有文件 IO 走 `asyncio.to_thread` 不阻塞事件循环；`GET /scan`(+`/scan/stream`)、`POST /preview`、`POST /apply`(+`/apply/stream`)、`GET /backups`、`POST /rollback/{id}`；**子串安全替换**（基于 token span，不会误伤子串）、`expected_total` 乐观锁（409）、写前自动磁盘备份到 `{skills_root}/.address-edits/`（同时写一份 `{id}.manifest.json` 记录本次替换明细，供修改记录展示）、应用后刷新技能系统提示缓存。纯引擎 `deerflow/skills/address_scan.py`，router `app/gateway/routers/skill_addresses.py`，tests `tests/test_skill_addresses.py`。范围仅运行中技能，不动 `deploy/minimal/skills/`。
+- **按钮管理 (Task Button Management, admin-only)**: configures the **可配置跳转按钮** rendered in the left task panel of the task deep-link workspaces (rwfx / 3qfx / xdfx, see `TaskFxWorkspace`). Each button = `{business, label, linkType, target, appendTaskId, idParam, idKind, openMode, loginParams, appendAuth, authTokenParam, authNameParam, enabled, sortOrder}`; `linkType` is `url` (外链 `window.open`, optional append of `?{idParam}={id}` — **`idParam` is the editable query-param name**, e.g. `id`/`task_id`), `business` (内部切换到另一业务, reuses `resolveTaskDeeplinkTarget`, always task id), or `purpose` (弹出当前任务的「任务目的」表格 via the shared `TaskPurposeDialog`, no target — configurable for any page incl. xdfx). **`url` buttons support two independent, coexisting login-append mechanisms**: (1) **`loginParams` (追加登录参数, like 应用管理/Light App Center)** — a list of `{key, source, customValue}` resolved at click time: `runTaskButton` reads `userInfo` (via `readUserInfo` from `strategy-components/lib/light-app`, embed-isolated through `authStorage`) and appends `?{key}={value}` for each (`source` = a userInfo field such as `accessToken`/`yUserId`, or `other` → literal `customValue`); empty list = nothing appended. Reuses `LOGIN_SOURCE_OPTIONS` from light-app; stored as JSON column `task_buttons.login_params_json` (`PortableJSON`, migration `20260625_01`). (2) **`appendAuth` (追加登录态)** — appends `?{authTokenParam}={token1}&{authNameParam}={username}` (default param names `token`/`username`) so the跳转目标外部系统 can identify the current user — e.g. `…/action/sentiment?token=<JWT>&username=lizhaoxing`. **Gated on token login**: `token1` = the `?authToken=` used by token-exchange login; `username` = the raw login name the backend resolved from `getTokenInfo`. Both are stashed at login by `persistLoginCredentials` into `login.token1`/`login.username` (`core/auth/login-credentials.ts`, scoped via [[scoped-storage]] so嵌入/独立会话隔离 + 随独立会话迁移). Only token login writes them → a non-token-login session has no `token1`, so `runTaskButton` silently skips the auth append (the jump still works, just without those two params). The frontend reads `username` straight from the new `UsernameLoginResponse.username` field (the stored email local-part is lossy — lowercased/normalized — so not used), **not** by decoding the JWT. Stored as columns `task_buttons.{append_auth, auth_token_param, auth_name_param}` (migration `20260625_02`). The admin page renders both editors for `url` buttons (loginParams 虚线框 + 追加登录态 switch). **`idKind` (`task`/`action`) only matters for xdfx**: its deep-link `?taskId=` is an 行动id and the 任务id is resolved at login (`fetchTaskIdFromAction`) — `TaskContext` now also stashes the raw `actionId`, so a url button can append either (default `task`). Page `TaskButtonsPage.tsx` (route `/page/strategy/admin/task-buttons`, **admin-gated**, entry「按钮管理」in the bottom-left settings dropdown of `components/page-sidebar.tsx`, both full + collapsed modes) has per-business tabs, edits name/type/target/启停/排序/增删, saves the **whole set atomically** (replace-all), plus 「导入默认」 to merge code-seed defaults. **Seed/fallback** (like 敏感词管理): only when the whole table is empty (fresh deploy, never saved) do the workspace + page fall back to `defaultTaskButtons(cfg)` — rwfx's url buttons (编辑/上一步/下一步/3q详情) built from the **live** `/api/public/config/task-deeplink` plus cross-business switch buttons for **all three** businesses (each switches to the other two — rwfx→三情/行动, 3qfx→任务/行动, xdfx→任务/三情). Once saved, the store is the sole source of truth. **Bottom 快捷跳转 bar groups by prev/next**: `TaskJumpBar` renders only「上一步/下一步」-type buttons in the bottom bar — a `prev` group (id 含 `prev` 或文案「上一步」, 描边次要样式 + ←图标) rendered **左侧**, then a `next` group (id 含 `next` 或文案「下一步」, 实心主色) on the **右侧** (container `justify-end`); everything else goes to the right-edge floating menu. The default 上一步 button (`rwfx-prev`, `url`, target = `DASHBOARD_AGENT_ROUTE` `/page/strategy/dashboard-agent`, `appendTaskId` + `idParam=taskId` → `?taskId=任务id`, `openMode=self`) 默认指向**应用内**「大屏绘制」页，在 **both** 单智能体 (`TaskFxWorkspace`) 与 多智能体会商 (`RoundtablePlanningPage` 深链 rwfx-A) 都显示（共用 `TaskJumpBar`）。**`runTaskButton` 的 `url` 类型支持应用内路由**：target 以单个 `/` 开头时按内部路由处理——`self` 走 react-router 同窗导航（不刷新），`blank` 拼成当前源的 hash 路由新标签打开；外链行为不变。 The old hardcoded jump buttons were migrated out: `TaskFxWorkspace` no longer hardcodes 切换到三Line truncated
+- **实时并发监控 (Concurrency / System-Pressure Monitor, admin-only)**: a live panel mounted at the **top of the admin 排行榜 page** (`components/workspace/admin/concurrency-monitor.tsx` `ConcurrencyMonitorPanel`, rendered in `pages/AdminUserLeaderboardPage.tsx`) showing **当前并发的大模型调用数 + 列表（用户/智能体/类型/已运行时长）**, each row with a 「停止」button (and a 「全部停止」) that **truly aborts** that run's in-flight model stream via `RunManager.cancel` (`POST /api/admin/active-runs/{run_id}/cancel`) — to relieve pressure when 使用人数过多. Two line charts (minute/hour toggle): **并发量折线图** (peak/avg, `GET /api/admin/active-runs/concurrency`, fed by a lightweight background sampler into `concurrency_samples`) and **大模型出字速度折线图** (tokens/sec, `GET /api/admin/active-runs/token-speed`, aggregated from `llm_call_metrics`) so a dip pinpoints where the bottleneck is. A **「后台采样」Switch** (`system_settings.json → concurrency_monitor.enabled`, **default off / opt-in**, `GET|PUT /api/admin/active-runs/settings`) turns the background sampling on/off **at runtime, no restart** (the live concurrency count + 「停止」 work even while sampling is off — only the 并发量 history chart needs it on); everything is designed to **never impact production** (one tiny INSERT/15s, retention-purged, best-effort). Client/hooks: `core/admin/active-runs.ts` + `core/admin/hooks.ts` (`useActiveRuns`/`useConcurrencySeries`/`useTokenSpeedSeries`/`useCancel*`/`useMonitorSettings`). See the backend CLAUDE.md「Admin Concurrency Monitor」.
+- **会话冲突 409 中文化**: when a user submits a new question while the previous turn is still streaming, the backend's `RunManager.create_or_reject` rejects with HTTP 409 (`services.py` now returns a **Chinese** detail「当前对话还在生成回答…」). `core/threads/hooks.ts` `onError` detects the conflict (`isActiveRunConflictError`: 409 / "already has an active run" / the Chinese text) and shows a friendly `toast.info` instead of a raw error.
 - **State**: TanStack Query for server state, context providers (`SubtasksProvider`, `ArtifactsProvider`, `PromptInputProvider`) scoped to `WorkspaceRoutes`
 - **LLM streaming**: `@langchain/langgraph-sdk` streams messages from the backend via SSE
 - **UI**: Radix UI primitives + TailwindCSS v4 + shadcn-style components in `src/components/ui/`
 - **Shims**: `src/shims/` provides `next/link` and `next/navigation` polyfills (original code was Next.js)
+- **Login URL params** (`LoginPage.tsx`, frontend-only — the backend never sees these): besides the auth params (`ticket`/`userId`/`env`/`theme`/`yUserId`/`token`/`access_token`/`authToken`/`password`), the page supports a **task deep-link** via `?taskId=&goPath=`. After login it calls the consumer API `GET {VITE_AIPI_CONSUMER_URL}/taskAnalyseSearch/cop-task-detail?taskId=` (header `Authorization: Bearer admin`, auto-injected by `utils/request.ts`), stashes the full `data` (`id/overview/taskDirection/taskName/taskContent`) into `sessionStorage["login.copTaskDetail"]`, then routes by `goPath`: base codes `3qfx`/`rwfx`/`xdfx` → that business's configured **single agent** Q&A inside a **任务工作区** (resolved via `/api/business-mapping`; `resolveTaskDeeplinkTarget` calls `persistTaskContext({taskId, agentId, openingText})` and navigates to the `…/chats` **index**, which opens the latest task conversation or 新建 — a 1:N task↔对话 workspace, NOT `pendingAgentMessage`); the `-A` suffix (`3qfx-A`/…) → **multi-agent roundtable** with `roundtablePrefill.businessCode` so the page auto-selects the configured 业务链条. **xdfx's deep-link `?taskId=` is actually an 行动id, not a 任务id** — `resolveDeeplinkTaskId(goPath, rawId)` (called in `LoginPage` before everything) detects `xdfx`/`xdfx-A` and resolves it via `GET {action_detail_url}/{actionId}` → `data.taskId` (`fetchTaskIdFromAction`; `action_test`+`mock.action_detail` for offline testing); the resolved 任务id then drives `cop-task-detail`, the purpose tree, and the 1:N binding (other businesses pass the id through unchanged). **xdfx additionally partitions its chat records by 行动id (action_id), NOT by task_id**: `resolveTaskDeeplinkTarget` sets `partitionByAction:true` + keeps the raw action_id as `TaskContext.actionId`, so new threads are tagged `metadata.{taskId,actionId}` (taskId kept only to preserve the backend「任务深链对话全局共享」semantics, which keys off `metadata.taskId`) and the conversation list filters by `actionId` (+`agent_id`) — different actions of the same task get separate lists. xdfx's first-question opening text also appends `行动id（action_id）为…` (see `buildOpeningText` / `taskThreadMetadata`). goPath→businessCode: `3qfx`→`3Q`, `rwfx`→`6BF`, `xdfx`→`7BF`. The roundtable target also threads the URL `taskId` into `roundtablePrefill.taskId` (`resolveTaskDeeplinkTarget(goPath, detail, taskId)`), which turns on two taskId-scoped behaviors: (1) **separate, unpartitioned per-task storage** — taskId 会商聊天记录 live in their **own** store/table (`roundtable_task_drafts`), keyed **only by `task_id`** (one taskId = many records, shared across users, **no user 分权** at all; `created_by` is audit-only), kept entirely out of the per-user personal store (`roundtable_drafts`, now strictly per-user) so the two never mix. Backend router `/api/roundtable-task-drafts` (`GET /by-task/{id}` + `/by-task/{id}/latest`, `POST`, `GET/PUT/DELETE /{id}` — all user-agnostic); frontend client `roundtable-planning/api/task-drafts.ts`, and `useDraftPersistence`/`useRoundtableDrafts` route **all** CRUD to it when a `taskId` is present (else the personal `drafts.ts`). The matching **background jobs** are shared by task too: `roundtable_jobs.task_id` marks a task job; reads/dedup/stream/resume/cancel pass `?task_id=` so any user opening the task sees the same running 研讨 (progress/flowchart), and the executor writes the final report back to the task-draft store. Existing rows are moved over by `scripts/migrate_roundtable_task_drafts.py` (migration `20260618_01`). The history dropdown filters to the task and 新建 keeps the binding; (2) **Step-3 auto structured output** — after the `roundtable-summary` agent writes the Markdown report it automatically runs a second round emitting a `flow-json` flowchart (`useStep3Summary` `autoFlow`+`chainLevels`), whose hierarchy follows the business chain's stage goals (任务 → 目的 → 行为体 → …; coordinatorPrompt-specified hierarchy wins) and whose nodes never carry 阶段编号/阶段名 (the prior bug). **Both targets render embedded under the 任务管理 layout** — nested routes under `task-management/<business-path>/{roundtable,agent/:agent_id/chats}` in `StrategyRoutes.tsx` (`<business-path>` = `plan-task-sentiment` / `plan-task/plan-task-fx` / `plan-task/plan-task-action`, matching the COH中任务 menu paths in `sidebar-menu.ts`) so the global sidebar keeps 任务管理 → COH中任务 → the matching business highlighted. **All three single-agent businesses share `TaskFxWorkspace`** (`task-components/TaskFxWorkspace.tsx`): left = a「当前任务」card (`readCopTaskDetail()` 任务名称 + 简介, desensitized, 留存 above 新建对话) + per-task 1:N conversation list (`useTaskThreads(taskId, agentId, actionId?)` — filtered by **both** `metadata.taskId` AND `metadata.agent_id` so the three businesses' conversations staLine truncated
+- **iframe 嵌入模式 (外部系统用 iframe 套用深链问答/会商)** — 三个**按标签页**开关，全部由深链 URL 参数开启、存进同一份 `sessionStorage` 会话（`embed.session`，键名常量在 `core/embed/embed-session.ts`），跨登录跳转/刷新/页内导航存活，**绝不跨标签污染**同浏览器另开的正常系统页。核心隔离手法：用 `sessionStorage`（按标签页/浏览上下文隔离，iframe 即便同源也有独立一份）而非 `localStorage`（跨标签共享）。开关：(1) **`?embed=1`（可带 `&theme=`）** — 去全局 chrome（`PageLayout` 的 `pageSidebarAllowed && !isEmbedActive()` → 隐藏 Header + PageSidebar）+ 按外部主题色**强制**明/暗：走 next-themes 的 `forcedTheme`（`App.tsx` `AppProviders` 调 `resolveForcedEmbedTheme`，**不写** localStorage `strategy-theme`），离散映射 `dark-blue`/`dark`→深、其余→浅；嵌入侧**绝不**调 `setTheme`/`persistSidebarEnabled`（那俩落 localStorage 跨标签污染，`LoginPage` 据 `readEmbedParam` 跳过）。(2) **`?hideJump=1`** — 隐藏深链底部「快捷跳转」栏 `TaskJumpBar` 的两部分（底部「下一步」等按钮 + 右侧垂直居中悬浮菜单），单智能体问答 + 会商共用该栏，`isJumpBarHidden()` 为真时整条 `return null`。(2.5) **`?hideChrome=1`** — **仅**去全局 chrome（Header 导航栏 + PageSidebar 侧边栏），**不**强制主题、**不**隔离鉴权（区别于 `embed`：只想要一个干净全屏页面，如「大屏绘制」`/page/strategy/dashboard-agent?taskId=…&hideChrome=1`）。新增 `EmbedSession.hideChrome` 字段 + `readHideChromeParam()` + `isChromeHidden()`（取 `embed || hideChrome` 之并），与 `hideJump` 完全对称；`PageRoutes.tsx` 的 `PageLayout` 把 `chromeHidden`（`isChromeHidden() || readHideChromeParam(location.search)==="on"`）并入 `pageSidebarAllowed`，且其**优先级高于** dashboard-agent 路由原本的强制全局 chrome（`forceChromeForDashboardAgent`）。`hideChrome=0` 可显式关闭。(3) **登录用户隔离** — 嵌入态下鉴权/身份键（`deerflow.auth` token、`userInfo`、`login.*`、`tools_token`、maxkey/userDetail token）全部经 `core/auth/scoped-storage.ts` 的 `authStorage()`（嵌入→sessionStorage / 正常→localStorage）读写，使 iframe 里登录的用户与正常登录用户**完全隔离**、互不覆盖；所有 token 读取都过 `getStoredAuth()`/`getAuthorizationHeaderValue()`（API 客户端 `core/api/*` 全走这俩），改中心函数即让全体调用方自动隔离；跨标签账号变更监听 `AuthSyncWatcher`（`core/auth/sync.tsx`）在嵌入态禁用。嵌入会话在 `main.tsx` 渲染前 `syncEmbedSessionFromCurrentUrl()` 同步启用（早于任何鉴权写入，避免首帧 effect 顺序漏写 localStorage）；`AppProviders` 的 effect 再按 SPA 导航同步。`embed=0`/`hideJump=0` 可显式关闭。正常（非嵌入）标签页所有 `isXxx()` 恒 false，行为**零变化**。第三个开关 `?isolate=1`（**独立登录会话**）把同一套**登录用户隔离**单独提供给**普通（带 chrome）标签页**——只切换鉴权存储、不去 chrome / 不强制主题 / 不动跳转栏：`authStorage()` 的条件从「仅嵌入」放宽为 `isEmbedActive() || isIsolatedSession()`，`AuthSyncWatcher` 的跨标签监听对嵌入态**或**独立态都即时忽略（handler 内实时判，运行时开关也即刻生效）。除 URL 参数外，**设置 → 外观 →「登录会话」** 有一个 Switch「独立登录会话（本标签页）」运行时切换（`setIsolatedSession`，`appearance-settings-page.tsx`）：**开启时先 `migrateAuthToSession()`**（`scoped-storage.ts`，把 localStorage 的受保护键 `deerflow.auth`/`userInfo`/`userId`/`tools_token` + `login.*` 前缀快照搬进 sessionStorage）再翻标志，故无感不登出；此后本标签页登录态独立——别处登录/换号影响不到它，它换号也影响不到别人，但关掉该标签即结束（需重登）。开启给 toast 提示。
+- **操作日志（Y-Log）上报** — 用户的关键操作（登录登出/查询/查看/增删改/启停/导入导出/问答等）成功后，**前端直连**外部接口 `POST {write_url}`（默认 `https://ch1.b.uat.4.cn/api/y-log/write`）记一条审计日志。核心模块 `src/core/log/`：`y-log.ts`（`writeYLog(params)` + `OptType` 枚举 0/1/3..12；**异步即发即忘、永不 await、永不抛错、失败静默**，自动把完整 url 转相对路径去 ip/host、对象入参/返回自动 `JSON.stringify` + 50k 裁剪、`optResult` 恒 0 只报成功），`y-log-config.ts`（从公开只读 `GET /api/public/config/y-log` 拉 `{enabled, writeUrl}`，模块级缓存 + 去重 + 默认兜底；`App.tsx` `AppProviders` 启动预热 `fetchYLogConfig()`），`y-log-token.ts`（token1 = token 登录的 `?authToken=`，经 [[scoped-storage]] 的 `authStorage*` 存取，嵌入态自动隔离）。**双门控**：仅当①存在 token1（即用 token 登录，`LoginPage` 成功后 `persistYLogToken(authToken)`，登出 `account-settings-page.tsx` 先报后清 token1）且②配置 `enabled && writeUrl` 才上报；否则一律不发。`optDetail` 统一「CM助手-全量-…」（**禁内部框架名**）。埋点**广覆盖**各 API client 的成功路径——原则是「一个用户操作（查看/查询/新增/编辑/删除/启停/导入导出）= 一条日志」，每个 API client 的**单条详情 GET（查看→view 4）/ 列表查询 GET（search 3）/ 新增 POST（create 9）/ 改 PUT·PATCH（edit 5）/ 删 DELETE（delete 6）/ 启停（enabled 11 / disabled 10）/ 导入导出（import 7 / export 8）**都各落一条，仅跳过高频 typeahead/状态轮询/纯 bootstrap config 读。覆盖文件：`strategy-components/api/{sensitive-words,menu-overrides,task-buttons,skill-addresses,light-apps,business-mapping}.ts`、`roundtable-planning/api/{drafts,task-drafts,roundtable-jobs,recommend,chains,multi-agent,dashboard-sessions}.ts`、`core/{agents,scheduled-tasks,knowledge,positions,tags,studio,system-settings,memory,mcp,models,custom-prompts,user-preferences,notifications,recommended-questions,user-qa,curator,admin,thread-shares,roundtable-draft-shares,tool-metrics,llm-metrics,note,artifacts}/api.ts`、`core/api/markdown-docx-export.ts`。**问答（Q&A）改为「一次大模型调用 = 一条日志」**：在共享的 `core/threads/hooks.ts` `useThreadStream` 的 `onLangChainEvent` 里监听 `on_chat_model_end`，每次模型调用结束就上报一条（optType 12，`reqParam` 取本次 input 的最后一条 user 文本 + 模型名，`returnParam` 取本次输出文本）——一个问答轮次里 lead agent / 子代理的**每次** LLM 调用都各记一条，覆盖所有走 `useThreadStream` 的页面（`ChatPage`/`AgentChatPage`/创建智能体/iframe/会商等）；`ChatPage`/`AgentChatPage` 的 `onFinish` 仍额外保留一条轮次汇总。后端仅新增公开只读配置：`deerflow/config/y_log_config.py`（`YLogConfig{enabled,write_url}`）挂到 `AppConfig.y_log`，`app/gateway/routers/public_config.py` 加 `GET /api/public/config/y-log`，地址写在 `config.yaml` 的 `y_log` 段（mtime 热重载，前端无需重建）；**不做后端代理**。Tests：`tests/test_y_log_config.py`。
 
 ### Configuration
 

batch-distill/README.md

@@ -0,0 +1,33 @@
+# 批量人物蒸馏 → llmwiki
+
+一个**完全独立的单文件脚本 + 内置定时器**：读 Excel 名单，串行调用线上 DeerFlow 服务问答接口，
+复用「女娲 / huashu-nuwa」技能逐个蒸馏人物，**由脚本抓取回复并保存**成 llmwiki 风格 markdown。
+
+- **不联网**：只用已配置的知识库查询技能（`knowledge-search-v2`）检索资料。
+- **定时执行**：每天 **23:00 ~ 次日 08:00** 自动跑，到点暂停、次日继续。
+- **md 由 py 保存**：agent 只产出内容，脚本抓最终回复写成 `.md`（不让项目自己写文件）。
+
+## 你只需要做两件事
+
+1. **改一行地址**：打开 `distill_people.py`，把顶部 `BASE_URL = "..."` 改成你的线上服务地址。
+2. **放名单**：同目录放 `people.xlsx`（或 `people.csv`），**第一列 = 人名**，其余列=可选提示。
+
+其余（用户名 `distiller`、口令 `123ewq`、技能名、时间窗）都已内置，不用填。
+
+## 运行
+
+```bash
+python distill_people.py          # 常驻，按 23:00~08:00 窗口自动执行（推荐挂后台）
+python distill_people.py --now    # 忽略时间窗，立刻把名单跑完（测试用）
+python distill_people.py --redo   # 忽略已完成，全部重做
+```
+
+读 `.xlsx` 需要 `openpyxl`；用 `.csv` 则零额外依赖。
+
+## 输出（都在 output/ 一个文件夹）
+
+- `<人名>.md` —— 每个人的 llmwiki 档案
+- `manifest.json` —— 执行清单（状态/耗时/run_id）
+- `index.md` —— 可读清单表（谁完成/失败，点开看 md）
+
+**断点续跑**：已完成的人自动跳过；中途往名单里加人，下个执行窗会带上。

batch-distill/distill_people.py

@@ -0,0 +1,563 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+批量人物蒸馏 → llmwiki markdown（完全独立的单文件客户端 + 内置定时器）
+
+特点
+----
+- 串行（一个一个来）调用正在运行的 DeerFlow 服务问答接口
+- 复用线上「女娲 / huashu-nuwa」技能做提炼；**不联网**，只用已配置的
+  知识库查询技能（knowledge-search-v2）检索资料
+- agent 只负责产出内容，**markdown 由本脚本抓取最终回复后自己保存**
+- 内置时间窗：每天 23:00 ~ 次日 08:00 才执行，到点自动暂停、次日继续
+- 断点续跑：已完成的人自动跳过；中途加名单也会被带上
+
+你只需要改一处：下面的 BASE_URL（线上服务地址）。其余都不用填。
+
+名单
+----
+脚本同目录放 people.xlsx 或 people.csv，**第一列 = 人名**，其余列=可选提示。
+
+运行
+----
+    python distill_people.py            # 常驻，按 23:00~08:00 窗口自动执行
+    python distill_people.py --now      # 忽略时间窗，立刻把名单跑完（测试用）
+    python distill_people.py --redo      # 忽略已完成，全部重做
+"""
+from __future__ import annotations
+
+import argparse
+import csv
+import json
+import re
+import sys
+import time
+from datetime import datetime, time as dtime
+from pathlib import Path
+
+try:
+    import requests
+except ImportError:
+    sys.exit("缺少依赖 requests：pip install requests")
+
+
+# ════════════════════════════════════════════════════════════════════════
+#  只改这一行：你的线上服务地址（不带结尾斜杠）
+# ════════════════════════════════════════════════════════════════════════
+BASE_URL = "http://47.94.209.59:2026/"
+# ════════════════════════════════════════════════════════════════════════
+
+
+# ---- 以下都已内置，正常无需改动 ----
+USERNAME = "distiller"          # 免密自动注册
+PASSWORD = "123ewq"             # 共享口令（你们开了口令门）
+NUWA_SKILL = "huashu-nuwa"      # 女娲技能
+KB_SKILL = "knowledge-search-v2"  # 知识库查询技能（不联网，用它检索）
+DEPTH = "full"                  # full 完整 / fast 精简
+
+HERE = Path(__file__).resolve().parent
+OUTPUT_DIR = HERE / "output"
+PEOPLE_FILE_DEFAULT = HERE / "people.example.csv"
+
+# 执行时间窗：23:00 ~ 次日 08:00（跨午夜）
+WIN_START = dtime(23, 0)
+WIN_END = dtime(8, 0)
+
+PER_PERSON_TIMEOUT = 1800       # 单人最长等待（秒）
+POLL_INTERVAL = 5               # 轮询间隔（秒）
+HTTP_TIMEOUT = 60
+TERMINAL_STATUS = {"success", "error", "timeout", "interrupted"}
+
+
+# ================================ llmwiki 模板 ================================
+LLMWIKI_TEMPLATE = """\
+---
+name: <中文名/常用名>
+aliases: [<别名/英文名...>]
+type: person
+era: <在世 | 历史人物>
+domains: [<领域1>, <领域2>]
+distilled_at: <YYYY-MM-DD>
+sources_count: <检索到的来源条数>
+primary_source_ratio: <一手来源占比, 0~1 的小数>
+confidence: <high | medium | low>
+---
+
+# <人物名>
+
+> **一句话定位**：<此人看世界的独特方式，一句话>
+
+## 身份卡
+- **活跃年代**：
+- **核心身份**：
+- **自述(50字, 以其语气)**：
+
+## 核心观点（真信念 · 反复出现的主张）
+1. ...
+
+## 心智模型（3–7 个；每个含：一句话 / 证据场景≥2 / 应用 / 局限 / 来源）
+### 1. <模型名>
+- **一句话**：
+- **证据场景**：
+- **应用方式**：
+- **局限**：
+- **来源**：
+
+## 决策启发式（5–10 条 · 如果 X 则 Y，带案例）
+- 若 <X> → <Y>
+
+## 表达 DNA
+| 维度 | 特征 |
+|------|------|
+| 句式 | |
+| 高频词 | |
+| 幽默 | |
+| 确定性 | |
+| 引用习惯 | |
+
+## 价值观与反模式
+- **价值观排序**：
+- **明确反对**：
+
+## 内在张力（≥2 对矛盾）
+- <A> ↔ <B>
+
+## 经历时间线
+| 年份 | 事件 | 思想意义 |
+|------|------|---------|
+| | | |
+
+## 代表语录
+- “...” —（出处/年份，标一手/二手）
+
+## 智识谱系
+- **受影响于**：
+- **影响了**：
+
+## 外部评价与争议
+-
+
+## 诚实边界
+- <至少 3 条具体局限，含信息截止日期>
+
+## 调研来源
+**一手(N)**：
+**二手(N)**：
+"""
+
+
+def build_prompt(name: str, hints: str, depth: str) -> str:
+    depth_note = (
+        "本次走【完整模式】：尽量覆盖著作/对话/表达/他者评价/决策/时间线 6 个维度。"
+        if depth == "full"
+        else "本次走【精简模式】：重点覆盖核心观点、心智模型、时间线三块即可。"
+    )
+    hint_block = f"\n补充提示（来自名单其它列，可作为检索关键词）：{hints}\n" if hints.strip() else ""
+    return f"""\
+你的任务：把人物【{name}】蒸馏成一份 llmwiki 风格的人物档案 markdown。
+
+请复用本服务中已启用的「女娲 / {NUWA_SKILL}」技能的提炼方法论
+（心智模型三重验证、表达DNA分析、诚实边界）。
+
+⚠️ 本环境**无法联网，严禁使用 WebSearch 等任何联网工具**。
+所有资料**只能通过已配置的知识库查询技能「{KB_SKILL}」检索获取**。
+请充分调用该知识库技能，围绕该人物多角度检索（生平、观点、著作、语录、决策、评价等），
+基于检索到的内容做提炼。知识库里查不到的部分，如实在「诚实边界」标注，不要编造。
+
+{depth_note}
+{hint_block}
+输出要求：
+1. **不要写任何文件，不要调用 write_file / present_files**。
+2. 直接在你的回复正文里输出**完整中文 markdown 全文**，严格按下面模板结构
+   （保留各级标题，逐项填实，不要保留尖括号占位符），**不要任何额外解说、前言或结语**：
+
+------------------ 模板开始 ------------------
+{LLMWIKI_TEMPLATE}
+------------------ 模板结束 ------------------
+
+现在开始，独立完成，不要向我提问。"""
+
+
+# ================================ HTTP 客户端 ================================
+class DeerFlowClient:
+    def __init__(self, base_url: str):
+        self.base = base_url.rstrip("/")
+        self.s = requests.Session()
+        self.token: str | None = None
+
+    def _headers(self) -> dict:
+        h = {"Content-Type": "application/json"}
+        if self.token:
+            h["Authorization"] = f"Bearer {self.token}"  # 只用 Bearer，不带 cookie → 跳过 CSRF
+        return h
+
+    def login(self) -> bool:
+        url = f"{self.base}/api/v1/auth/login/username"
+        params = {"password": PASSWORD} if PASSWORD else None
+        try:
+            r = self.s.post(url, params=params, json={"username": USERNAME}, timeout=HTTP_TIMEOUT)
+        except requests.RequestException as e:
+            print(f"  [登录] 连接失败：{e}")
+            return False
+        if r.status_code == 200:
+            self.token = r.json().get("access_token")
+            self.s.cookies.clear()
+            print(f"  [登录] 成功，用户={USERNAME}")
+            return True
+        print(f"  [登录] 返回 {r.status_code}：{r.text[:200]}")
+        return False
+
+    def ensure_skill_enabled(self, name: str) -> None:
+        try:
+            r = self.s.get(f"{self.base}/api/skills", headers=self._headers(), timeout=HTTP_TIMEOUT)
+            if r.status_code == 200:
+                skills = r.json().get("skills", [])
+                hit = next((x for x in skills if x.get("name") == name), None)
+                if hit is None:
+                    print(f"  [技能] 警告：服务里没找到 '{name}'")
+                    return
+                if hit.get("enabled"):
+                    print(f"  [技能] '{name}' 已启用")
+                    return
+            pr = self.s.put(f"{self.base}/api/skills/{name}", headers=self._headers(),
+                            json={"enabled": True}, timeout=HTTP_TIMEOUT)
+            print(f"  [技能] 启用 '{name}' → {pr.status_code}")
+        except requests.RequestException as e:
+            print(f"  [技能] 检查 '{name}' 失败（忽略）：{e}")
+
+    def create_thread(self) -> str:
+        r = self.s.post(f"{self.base}/api/threads", headers=self._headers(), json={}, timeout=HTTP_TIMEOUT)
+        r.raise_for_status()
+        return r.json()["thread_id"]
+
+    def start_run(self, thread_id: str, prompt: str) -> str:
+        body = {
+            "input": {"messages": [{"role": "user", "content": prompt}]},
+            "excluded_tools": ["ask_clarification"],  # 禁澄清，无人值守不卡住
+        }
+        r = self.s.post(f"{self.base}/api/threads/{thread_id}/runs",
+                        headers=self._headers(), json=body, timeout=HTTP_TIMEOUT)
+        r.raise_for_status()
+        return r.json()["run_id"]
+
+    def poll_run(self, thread_id: str, run_id: str) -> str:
+        deadline = time.monotonic() + PER_PERSON_TIMEOUT
+        last = ""
+        while time.monotonic() < deadline:
+            try:
+                r = self.s.get(f"{self.base}/api/threads/{thread_id}/runs/{run_id}",
+                               headers=self._headers(), timeout=HTTP_TIMEOUT)
+                if r.status_code == 200:
+                    st = r.json().get("status", "")
+                    if st != last:
+                        print(f"    ...状态：{st}")
+                        last = st
+                    if st in TERMINAL_STATUS:
+                        return st
+            except requests.RequestException as e:
+                print(f"    轮询出错（重试）：{e}")
+            time.sleep(POLL_INTERVAL)
+        return "timeout"
+
+    def fetch_result_text(self, thread_id: str, run_id: str) -> str | None:
+        """抓取该 thread 的最终 AI 回复文本（由 py 保存为 md）。
+
+        注意：本部署的 `/runs/{rid}/messages`、`/messages`、`/events` 端点都返回空
+        （事件库按登录用户过滤，后台 worker 写入时未带 user_id → 读不到）。
+        可靠来源是 LangGraph 检查点状态 `/api/threads/{tid}/state` → values.messages，
+        其中每条消息形如 {"type": "human"|"ai"|"tool", "content": <str | 内容块列表>, ...}。
+        取最后一条有正文的 ai 消息即可。
+        """
+        try:
+            r = self.s.get(f"{self.base}/api/threads/{thread_id}/state",
+                           headers=self._headers(), timeout=HTTP_TIMEOUT)
+            if r.status_code != 200:
+                print(f"    取回复返回 {r.status_code}：{r.text[:200]}")
+                return None
+            messages = (r.json().get("values") or {}).get("messages") or []
+            # 从后往前找最后一条「有正文」的 AI 回复（跳过只含工具调用的中间消息）
+            for msg in reversed(messages):
+                if not isinstance(msg, dict) or msg.get("type") != "ai":
+                    continue
+                txt = _extract_text(msg)
+                if txt and txt.strip():
+                    return txt
+        except requests.RequestException as e:
+            print(f"    取回复出错：{e}")
+        return None
+
+
+def _extract_text(payload) -> str:
+    """从一条消息的 content 里提取纯文本。
+
+    payload 可能是：
+      - LangChain 消息的 model_dump 字典（正文在 payload["content"]）
+      - 直接的字符串
+      - 内容块列表（[{"type":"text","text":"..."}, ...]）
+    """
+    if payload is None:
+        return ""
+    # 若是整条消息的 model_dump，正文在其 content 字段
+    if isinstance(payload, dict):
+        c = payload.get("content", payload.get("text", ""))
+    else:
+        c = payload
+    if isinstance(c, str):
+        return c
+    if isinstance(c, list):
+        parts = []
+        for b in c:
+            if isinstance(b, dict):
+                # 只取文本块，跳过 tool_use / thinking 等非文本块
+                if b.get("type") in (None, "text", "text_block"):
+                    parts.append(b.get("text") or b.get("content") or "")
+                elif b.get("text"):
+                    parts.append(b["text"])
+            elif isinstance(b, str):
+                parts.append(b)
+        return "\n".join(p for p in parts if p)
+    return str(c) if c else ""
+
+
+def _clean_markdown(text: str) -> str:
+    """去掉 agent 可能套上的 ```markdown ... ``` 围栏，并规整 YAML frontmatter。"""
+    t = text.strip()
+    m = re.match(r"^```(?:markdown|md)?\s*\n(.*)\n```$", t, re.S)
+    if m:
+        t = m.group(1).strip()
+    return _normalize_frontmatter(t)
+
+
+def _normalize_frontmatter(text: str) -> str:
+    """修复模型常见的 frontmatter 跑偏，让 YAML 能正常解析。
+
+    模型经常把字段名写成 markdown 加粗（``**name:**``）、加空行、留行尾双空格，
+    这些都会让 frontmatter 解析失败。这里把开头 ``---`` 到下一个 ``---`` 之间的内容
+    规整为干净的 ``key: value`` 形式。正文（第二个 ``---`` 之后）保持原样。
+    """
+    if not text.startswith("---"):
+        return text
+    # 拆出 frontmatter 块：开头 --- 与下一行单独的 --- 之间
+    m = re.match(r"^---[ \t]*\n(.*?)\n---[ \t]*\n?(.*)$", text, re.S)
+    if not m:
+        return text
+    body_fm, rest = m.group(1), m.group(2)
+    out_lines = []
+    for line in body_fm.splitlines():
+        s = line.rstrip()              # 去行尾双空格
+        s = s.replace("**", "")         # 去 markdown 加粗标记
+        if not s.strip():
+            continue                    # 丢掉空行
+        out_lines.append(s)
+    return "---\n" + "\n".join(out_lines) + "\n---\n\n" + rest.lstrip("\n")
+
+
+# ================================ 名单读取 ================================
+def slugify(name: str) -> str:
+    s = re.sub(r'[\\/:*?"<>|]+', "", name).strip()
+    s = re.sub(r"\s+", "_", s)
+    return s or "unnamed"
+
+
+def read_people(path: Path) -> list[dict]:
+    if not path.exists():
+        return []
+    rows: list[list[str]] = []
+    if path.suffix.lower() in (".xlsx", ".xlsm"):
+        try:
+            import openpyxl
+        except ImportError:
+            sys.exit("读取 .xlsx 需要 openpyxl：pip install openpyxl（或把名单存成 .csv）")
+        wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
+        for row in wb.active.iter_rows(values_only=True):
+            rows.append(["" if c is None else str(c).strip() for c in row])
+    elif path.suffix.lower() == ".csv":
+        with open(path, encoding="utf-8-sig", newline="") as f:
+            rows = [[c.strip() for c in r] for r in csv.reader(f)]
+    else:
+        sys.exit(f"不支持的名单格式：{path.suffix}（用 .xlsx 或 .csv）")
+
+    if rows and re.search(r"(姓名|名字|人物|name)", rows[0][0] if rows[0] else "", re.I):
+        rows = rows[1:]
+    people, seen = [], set()
+    for r in rows:
+        if not r or not r[0].strip():
+            continue
+        name = r[0].strip()
+        if name in seen:
+            continue
+        seen.add(name)
+        hints = " | ".join(x for x in r[1:] if x.strip())
+        people.append({"name": name, "hints": hints})
+    return people
+
+
+# ================================ 时间窗 ================================
+def in_window(now: datetime | None = None) -> bool:
+    now = now or datetime.now()
+    t = now.time()
+    return t >= WIN_START or t < WIN_END  # 跨午夜
+
+def seconds_until_window(now: datetime | None = None) -> int:
+    now = now or datetime.now()
+    if in_window(now):
+        return 0
+    target = now.replace(hour=WIN_START.hour, minute=WIN_START.minute, second=0, microsecond=0)
+    return max(1, int((target - now).total_seconds()))
+
+def sleep_interruptible(total: int) -> None:
+    end = time.monotonic() + total
+    while time.monotonic() < end:
+        time.sleep(min(30, max(1, int(end - time.monotonic()))))
+
+
+# ================================ 蒸馏单人 ================================
+def distill_one(client: DeerFlowClient, person: dict, out_dir: Path,
+                manifest: dict, save_manifest, depth: str) -> None:
+    name, hints = person["name"], person["hints"]
+    slug = slugify(name)
+    md_path = out_dir / f"{slug}.md"
+    t0 = time.time()
+
+    rec = {"name": name, "slug": slug, "status": "running",
+           "started_at": _now(), "file": f"{slug}.md"}
+    manifest[name] = rec
+    save_manifest()
+
+    try:
+        tid = client.create_thread()
+        run_id = client.start_run(tid, build_prompt(name, hints, depth))
+        status = client.poll_run(tid, run_id)
+        rec.update(thread_id=tid, run_id=run_id, run_status=status)
+
+        text = client.fetch_result_text(tid, run_id) if status == "success" else None
+        if status == "success" and text:
+            md = _clean_markdown(text)
+            md_path.write_text(md, encoding="utf-8")
+            rec["status"] = "succeeded"
+            rec["chars"] = len(md)
+            print(f"    ✅ 完成 → {md_path.name}（{len(md)} 字，耗时 {int(time.time()-t0)}s）")
+        else:
+            rec["status"] = "failed"
+            rec["error"] = f"run={status}, text={'有' if text else '无'}"
+            if text:
+                (out_dir / f"{slug}.partial.md").write_text(text, encoding="utf-8")
+            print(f"    ❌ 失败（run={status}）")
+    except Exception as e:
+        rec["status"] = "failed"
+        rec["error"] = str(e)
+        print(f"    ❌ 异常：{e}")
+
+    rec["finished_at"] = _now()
+    rec["seconds"] = int(time.time() - t0)
+    manifest[name] = rec
+    save_manifest()
+
+
+# ================================ 主流程 ================================
+def main():
+    ap = argparse.ArgumentParser(description="批量人物蒸馏 → llmwiki（定时窗 23:00~08:00）")
+    ap.add_argument("excel", nargs="?", default=str(PEOPLE_FILE_DEFAULT),
+                    help="名单文件（.xlsx 或 .csv），默认同目录 people.xlsx")
+    ap.add_argument("--now", action="store_true", help="忽略时间窗，立刻跑完整批（测试用）")
+    ap.add_argument("--redo", action="store_true", help="忽略已完成，全部重做")
+    args = ap.parse_args()
+
+    excel = Path(args.excel)
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+    manifest_path = OUTPUT_DIR / "manifest.json"
+
+    manifest: dict = {}
+    if manifest_path.exists():
+        try:
+            manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+        except Exception:
+            manifest = {}
+
+    # 校验名单存在
+    if not read_people(excel):
+        sys.exit(f"名单为空或不存在：{excel}\n请放 people.xlsx（第一列写人名）。")
+
+    # --redo：一次性清掉名单里这些人的旧记录，让他们重做一遍；
+    # 之后本次会话内跑成功的会正常计为「已完成」，循环才会往后推进
+    # （否则每轮 pending() 都把已完成的人当未完成，永远卡在第 1 个人）
+    if args.redo:
+        for p in read_people(excel):
+            manifest.pop(p["name"], None)
+
+    client = DeerFlowClient(BASE_URL)
+    if not client.login():
+        sys.exit("登录失败。请检查 BASE_URL 是否指向正在运行的服务、口令是否正确。")
+    client.ensure_skill_enabled(NUWA_SKILL)
+    client.ensure_skill_enabled(KB_SKILL)
+
+    def save_manifest():
+        manifest_path.write_text(json.dumps(manifest, ensure_ascii=False, indent=2), encoding="utf-8")
+        _write_index(OUTPUT_DIR, read_people(excel), manifest)
+
+    def pending() -> list[dict]:
+        people = read_people(excel)
+        out = []
+        for p in people:
+            r = manifest.get(p["name"], {})
+            done = r.get("status") == "succeeded" and (OUTPUT_DIR / f"{slugify(p['name'])}.md").exists()
+            if not done:
+                out.append(p)
+        return out
+
+    print(f"启动 | 服务={BASE_URL} | 输出={OUTPUT_DIR}")
+    print(f"模式={'立即跑完' if args.now else '定时窗 23:00~08:00'} | 名单={excel}")
+
+    try:
+        while True:
+            todo = pending()
+            if not todo:
+                print(f"[{_now()}] 全部已完成，待命中（每小时复查名单）...")
+                if args.now:
+                    break
+                sleep_interruptible(3600)
+                continue
+
+            if not args.now and not in_window():
+                wait = seconds_until_window()
+                nxt = datetime.now().replace(hour=WIN_START.hour, minute=0, second=0, microsecond=0)
+                print(f"[{_now()}] 不在执行窗口，剩 {len(todo)} 人待蒸；"
+                      f"休眠到 {nxt.strftime('%H:%M')}（约 {wait//60} 分钟）...")
+                sleep_interruptible(wait)
+                continue
+
+            # 在窗口内（或 --now）：处理一个人，然后回到循环重新判断窗口/名单
+            p = todo[0]
+            idx_total = len(read_people(excel))
+            done_n = sum(1 for v in manifest.values() if v.get("status") == "succeeded")
+            print(f"[{_now()}] ({done_n}/{idx_total} 已完成) 蒸馏：{p['name']}")
+            distill_one(client, p, OUTPUT_DIR, manifest, save_manifest, DEPTH)
+    except KeyboardInterrupt:
+        print("\n已手动停止。重跑脚本会从未完成处继续。")
+
+    ok = sum(1 for r in manifest.values() if r.get("status") == "succeeded")
+    fail = sum(1 for r in manifest.values() if r.get("status") == "failed")
+    print(f"\n结束：成功 {ok} / 失败 {fail}")
+    print(f"结果目录：{OUTPUT_DIR} | 清单：{manifest_path} | 索引：{OUTPUT_DIR/'index.md'}")
+
+
+def _now() -> str:
+    return time.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def _write_index(out_dir: Path, people: list[dict], manifest: dict) -> None:
+    lines = ["# 蒸馏执行清单", "", f"更新时间：{_now()}", "",
+             "| # | 人物 | 状态 | 字数 | 耗时 | 文件 |",
+             "|---|------|------|------|------|------|"]
+    badge = {"succeeded": "✅完成", "failed": "❌失败", "running": "⏳进行中"}
+    for i, p in enumerate(people, 1):
+        r = manifest.get(p["name"], {})
+        st = badge.get(r.get("status", ""), "⌛排队")
+        f = r.get("file", "")
+        link = f"[{f}]({f})" if r.get("status") == "succeeded" and f else "-"
+        lines.append(f"| {i} | {p['name']} | {st} | {r.get('chars','-')} | {r.get('seconds','-')} | {link} |")
+    (out_dir / "index.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+
+if __name__ == "__main__":
+    main()

batch-distill/people.example.csv

@@ -0,0 +1,4 @@
+姓名,领域(可选提示),资料链接或备注(可选)
+查理·芒格,投资/多元思维,
+理查德·费曼,物理/教学,
+纳瓦尔·拉维坎特,创业/杠杆,https://nav.al/

browser-extension/deer-web-clipper/README.md

@@ -0,0 +1,136 @@
+# zncm Web Clipper
+
+这是给 zncm 使用的 Chrome 插件，安装后默认连接 `config.js` 中配置好的服务地址。
+
+默认地址配置在 `browser-extension/deer-web-clipper/config.js`：
+
+```js
+globalThis.ZNCM_WEB_CLIPPER_CONFIG = Object.freeze({
+  defaultWebBaseUrl: "http://47.94.209.59:2026",
+  defaultApiBaseUrl: "http://47.94.209.59:2026",
+});
+```
+
+如果部署地址变化，只需要修改 `config.js` 里的这两个字段，然后重新加载插件。
+
+正常情况下不需要手动配置 URL，也不需要手动复制 token。
+
+## 能做什么
+
+1. 把当前浏览器标签页发送到 zncm，作为 Markdown 附件进入聊天。
+2. 接收 zncm 聊天中由 `browser_fetch_page` 工具创建的网页抓取任务。
+3. 插件在 Chrome 中打开目标网页，读取可见文本和表格，再把结果回传给 zncm。
+4. 在普通网页右下角显示“zncm 页面问答”浮窗，直接把当前页面内容交给 zncm 问答。
+5. 接收 zncm 的 `browser_act` 交互式操作任务：在 Chrome 中打开页面并按 zncm 的指令**操作页面**——点击、输入、滚动、等待、页内跳转，每一步把页面上的可交互元素清单和正文回传给 zncm，由 zncm 决定下一步（observe→act 循环）。
+
+## 页面操作（browser_act）
+
+除了只读抓取，zncm 还能驱动插件**实际操作网页**，完成登录、填表、翻页找数据等多步任务：
+
+1. zncm 调用 `browser_act` 工具，先 `navigate` 打开页面。
+2. 插件打开标签页（同一会话会复用这个标签页），扫描页面上的可交互元素，给每个元素编号后连同正文回传给 zncm。
+3. zncm 根据元素编号决定下一步（点第 3 个按钮、在第 1 个输入框填字……），再次调用 `browser_act`。
+4. 插件执行动作、重新扫描页面、回传新状态，如此循环，直到任务完成。
+5. 任务结束时 zncm 用 `action="close"` 关闭该会话标签页。
+
+支持的动作：`navigate`（打开/跳转 URL）、`click`（点击元素）、`type`（输入文字，可选回车提交）、`scroll`（滚动到元素或下翻一屏）、`wait`（等待某 CSS 选择器出现）、`extract`（重新读取正文）、`observe`（仅重新扫描）、`close`（关闭会话标签页）。
+
+> 提示：页面操作能力较强（可点击任意按钮、提交表单），可在后端 `config.yaml` 用 `browser_context.actions_enabled: false` 关闭，只保留只读抓取。
+
+## 后端启用
+
+在 `offline-backend-20260512/backend/config.yaml` 中保持：
+
+```yaml
+browser_context:
+  enabled: true          # 只读抓取 + 页面问答
+  actions_enabled: true  # 交互式页面操作 browser_act（不需要可设为 false）
+```
+
+修改配置后需要重启后端。
+
+## 安装插件
+
+1. 打开 Chrome 的 `chrome://extensions`。
+2. 开启右上角的“开发者模式”。
+3. 点击“加载已解压的扩展程序”。
+4. 选择目录：`browser-extension/deer-web-clipper`。
+5. 安装后插件名会显示为 `zncm Web Clipper`。
+
+## 安装即用
+
+插件默认已经开启：
+
+- 自动识别已打开 zncm 页面的服务地址。
+- 自动同步已登录 zncm 的 token。
+- 自动轮询 zncm 聊天触发的浏览器抓取任务。
+- 页面问答框默认开启。
+
+如果你打开的是 `config.js` 里配置的默认服务器，通常无需进入设置页。
+
+如果部署地址变了，保持一个已登录的 zncm 页面打开，然后在插件设置里点击：
+
+- `重新识别服务地址`
+- `同步 token`
+
+## 自动同步 Token
+
+插件会自动从两个位置获取登录 token：
+
+1. zncm API 域名下的 `access_token` Cookie，包括 HttpOnly Cookie。
+2. 已登录 zncm 前端页面里的浏览器本地登录态。
+
+切换登录账号后，插件后台每次轮询任务前都会重新同步 token；点击插件里的“同步 token”也可以立即刷新。
+
+如果当前浏览器已经登出 zncm，且打开的 zncm 页面里没有 token，插件会清空旧 token，避免继续用上一个账号请求。
+
+## 页面问答框
+
+安装插件后，普通 `http` / `https` 页面右下角会出现 `AI` 按钮。点击后可以在当前网页上直接提问，例如：
+
+```text
+总结这页的核心结论
+提取页面里的价格和时间
+这张表里哪个指标最高？
+```
+
+插件会读取当前页面可见文本和表格，发送到 zncm，并把 zncm 的回答显示回浮窗里。多轮追问会复用同一个 zncm 会话；如果页面 URL 变化，会自动重新开始当前页会话。
+
+是否显示问答框可以自己控制：
+
+- 插件弹窗里勾选或取消“启用页面问答框”。
+- 插件设置页里勾选或取消“启用页面问答框”。
+
+关闭问答框只会隐藏页面浮窗，不会影响“发送当前页”和 zncm 聊天中的 `browser_fetch_page` 抓取任务。
+
+## 手动发送当前网页
+
+点击插件图标，选择“发送当前页”。
+
+插件会读取当前页面的可见文本和表格，发送到 zncm，并打开一个新的 zncm 聊天页面。zncm 会把网页内容作为上传文件注入到首条问题里。
+
+## 在 zncm 聊天中触发浏览器抓取
+
+在 zncm 中输入带有明确 URL 的问题，例如：
+
+```text
+使用 browser_fetch_page 打开 https://example.com/report，提取页面里的关键表格数据并总结。
+```
+
+执行流程：
+
+1. zncm 调用 `browser_fetch_page` 工具创建浏览器任务。
+2. 插件后台轮询到任务。
+3. 插件在 Chrome 中打开目标网页。
+4. 插件提取页面文本和表格。
+5. 插件把结果回传给 zncm。
+6. zncm 基于回传内容回答你的问题。
+
+这个方式适合读取需要浏览器登录态、内网权限或当前 Chrome 环境才能访问的页面。
+
+## 注意事项
+
+- 目标 URL 必须是明确的 `http` 或 `https` 地址。
+- 插件不能读取 `chrome://` 等浏览器内部页面。
+- 如果目标网站阻止扩展脚本注入，抓取可能失败。
+- 后台任务默认会打开新标签页；是否抓取完成后关闭标签页，可在插件设置里配置。

browser-extension/deer-web-clipper/background.js

@@ -0,0 +1,905 @@
+importScripts("config.js", "shared.js");
+
+const ALARM_NAME = "deer-browser-task-poll";
+const LEGACY_LOCAL_API_BASE_URL = "http://localhost:8001";
+const LEGACY_LOCAL_WEB_BASE_URL = "http://localhost:5174";
+let pollTimer = null;
+let isPolling = false;
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function getSettings() {
+  const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+  const updates = {};
+  if (!settings.apiBaseUrl || settings.apiBaseUrl === LEGACY_LOCAL_API_BASE_URL) {
+    updates.apiBaseUrl = DEER_CLIPPER_DEFAULTS.apiBaseUrl;
+  }
+  if (!settings.webBaseUrl || settings.webBaseUrl === LEGACY_LOCAL_WEB_BASE_URL) {
+    updates.webBaseUrl = DEER_CLIPPER_DEFAULTS.webBaseUrl;
+  }
+  if (!settings.workerId) {
+    updates.workerId = deerMakeWorkerId();
+  }
+  if (Object.keys(updates).length > 0) {
+    await chrome.storage.sync.set(updates);
+    Object.assign(settings, updates);
+  }
+  return settings;
+}
+
+function pollIntervalMs(settings) {
+  const seconds = Number(settings.taskPollIntervalSeconds || DEER_CLIPPER_DEFAULTS.taskPollIntervalSeconds);
+  return Math.max(3, seconds) * 1000;
+}
+
+function originMatchPattern(value) {
+  try {
+    const url = new URL(deerNormalizeBaseUrl(value));
+    return `${url.protocol}//${url.host}/*`;
+  } catch {
+    return "";
+  }
+}
+
+function normalizeServiceBase(value) {
+  return deerNormalizeBaseUrl(value || "");
+}
+
+function serviceBaseFromTabUrl(value) {
+  try {
+    const url = new URL(value);
+    const path = url.pathname.replace(/\/+$/, "");
+    if (path === "/deerflow" || path.startsWith("/deerflow/")) {
+      return `${url.origin}/deerflow`;
+    }
+    return url.origin;
+  } catch {
+    return "";
+  }
+}
+
+function apiCandidatesForWebBase(webBase, currentApiBase) {
+  const candidates = [];
+  const add = (value) => {
+    const normalized = normalizeServiceBase(value);
+    if (normalized && !candidates.includes(normalized)) {
+      candidates.push(normalized);
+    }
+  };
+
+  add(currentApiBase);
+  add(webBase);
+  add(DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  add(LEGACY_LOCAL_API_BASE_URL);
+
+  try {
+    const url = new URL(normalizeServiceBase(webBase));
+    if (["5173", "5174", "3000"].includes(url.port)) {
+      const apiUrl = new URL(url.href);
+      apiUrl.port = "8001";
+      add(apiUrl.href);
+    }
+  } catch {
+    // Ignore invalid candidates.
+  }
+
+  return candidates;
+}
+
+async function browserContextStatus(apiBaseUrl) {
+  try {
+    const response = await fetch(`${apiBaseUrl}/api/browser-context/status`, {
+      credentials: "include",
+    });
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json().catch(() => null);
+    if (data && typeof data.enabled === "boolean") {
+      return data;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+function tabLooksLikeZncm(tab) {
+  const value = `${tab.url || ""} ${tab.title || ""}`.toLowerCase();
+  return (
+    value.includes("deerflow") ||
+    value.includes("deer") ||
+    value.includes("zncm") ||
+    value.includes("/page/workspace") ||
+    value.includes("/chats/") ||
+    value.includes("#/login")
+  );
+}
+
+async function findOpenZncmTabs(settings) {
+  const tabs = [];
+  const seen = new Set();
+  const addTabs = (items) => {
+    for (const tab of items || []) {
+      if (tab?.id && !seen.has(tab.id)) {
+        seen.add(tab.id);
+        tabs.push(tab);
+      }
+    }
+  };
+
+  for (const pattern of [
+    originMatchPattern(settings.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl),
+    originMatchPattern(DEER_CLIPPER_DEFAULTS.webBaseUrl),
+  ]) {
+    if (!pattern) {
+      continue;
+    }
+    try {
+      addTabs(await chrome.tabs.query({ url: pattern }));
+    } catch {
+      // Continue with broader discovery below.
+    }
+  }
+
+  try {
+    const allTabs = await chrome.tabs.query({ url: ["http://*/*", "https://*/*"] });
+    addTabs(allTabs.filter(tabLooksLikeZncm));
+  } catch {
+    // Ignore tab discovery failures.
+  }
+
+  return tabs;
+}
+
+async function discoverServiceBases(settings, force = false) {
+  if (!settings.autoDiscoverServiceUrl && !force) {
+    return settings;
+  }
+
+  let webBaseUrl = normalizeServiceBase(settings.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl);
+  let discoveredWebBaseUrl = webBaseUrl;
+  let source = "configured";
+  const tabs = await findOpenZncmTabs(settings);
+  if (tabs.length > 0) {
+    const tabBase = serviceBaseFromTabUrl(tabs[0].url);
+    if (tabBase) {
+      discoveredWebBaseUrl = tabBase;
+      source = `tab:${tabs[0].url || tabBase}`;
+    }
+  }
+
+  let apiBaseUrl = normalizeServiceBase(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  let verified = false;
+  for (const candidate of apiCandidatesForWebBase(discoveredWebBaseUrl, apiBaseUrl)) {
+    const status = await browserContextStatus(candidate);
+    if (status) {
+      apiBaseUrl = candidate;
+      webBaseUrl = discoveredWebBaseUrl;
+      verified = true;
+      source = status.enabled ? `${source}:browser_context_enabled` : `${source}:browser_context_disabled`;
+      break;
+    }
+  }
+  if (!verified && force) {
+    source = `${source}:api_not_verified`;
+  }
+
+  const next = {
+    ...settings,
+    apiBaseUrl,
+    webBaseUrl,
+    lastServiceSyncAt: new Date().toISOString(),
+    lastServiceSyncSource: source,
+  };
+
+  if (
+    force ||
+    settings.apiBaseUrl !== next.apiBaseUrl ||
+    settings.webBaseUrl !== next.webBaseUrl ||
+    settings.lastServiceSyncSource !== next.lastServiceSyncSource
+  ) {
+    await chrome.storage.sync.set({
+      apiBaseUrl: next.apiBaseUrl,
+      webBaseUrl: next.webBaseUrl,
+      lastServiceSyncAt: next.lastServiceSyncAt,
+      lastServiceSyncSource: next.lastServiceSyncSource,
+    });
+  }
+  return next;
+}
+
+async function getCookieToken(settings) {
+  if (!chrome.cookies?.get) {
+    return null;
+  }
+  const apiBaseUrl = deerNormalizeBaseUrl(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  try {
+    const cookie = await chrome.cookies.get({ url: apiBaseUrl, name: "access_token" });
+    if (cookie?.value) {
+      return { token: cookie.value, source: `cookie:${new URL(apiBaseUrl).host}:access_token` };
+    }
+  } catch (error) {
+    console.warn("Failed to read zncm access_token cookie", error);
+  }
+  return null;
+}
+
+async function getTokenFromOpenZncmTab(settings) {
+  const tabs = await findOpenZncmTabs(settings);
+  let sawZncmTab = false;
+
+  for (const tab of tabs) {
+    if (!tab.id) {
+      continue;
+    }
+    sawZncmTab = true;
+    try {
+      const [result] = await chrome.scripting.executeScript({
+        target: { tabId: tab.id },
+        func: deerExtractAuthTokenFromPage,
+      });
+      const tokenInfo = result?.result;
+      if (tokenInfo?.token) {
+        const tabBase = serviceBaseFromTabUrl(tab.url);
+        if (tabBase && settings.autoDiscoverServiceUrl && settings.webBaseUrl !== tabBase) {
+          await chrome.storage.sync.set({
+            webBaseUrl: tabBase,
+            lastServiceSyncAt: new Date().toISOString(),
+            lastServiceSyncSource: `token-tab:${tab.url || tabBase}`,
+          });
+        }
+        return {
+          token: tokenInfo.token,
+          source: tokenInfo.source || `tab:${tab.url || "open-deer-tab"}`,
+        };
+      }
+    } catch (error) {
+      console.warn("Failed to read zncm token from tab", tab.id, error);
+    }
+  }
+
+  if (sawZncmTab) {
+    return { token: "", source: "open-deer-tab", clearStale: true };
+  }
+  return null;
+}
+
+async function syncAuthToken(settings = null, forceStatus = false) {
+  let current = settings || (await getSettings());
+  current = await discoverServiceBases(current);
+  if (!current.tokenSyncEnabled && !forceStatus) {
+    return current;
+  }
+
+  const tokenInfo = (await getTokenFromOpenZncmTab(current)) || (await getCookieToken(current));
+  if (!tokenInfo?.token) {
+    if (tokenInfo?.clearStale && current.accessToken) {
+      const next = {
+        ...current,
+        accessToken: "",
+        lastTokenSyncSource: "cleared:open-deer-tab-no-token",
+        lastTokenSyncAt: new Date().toISOString(),
+      };
+      await chrome.storage.sync.set({
+        accessToken: "",
+        lastTokenSyncSource: next.lastTokenSyncSource,
+        lastTokenSyncAt: next.lastTokenSyncAt,
+      });
+      return next;
+    }
+    return current;
+  }
+
+  const next = {
+    ...current,
+    accessToken: tokenInfo.token,
+    lastTokenSyncSource: tokenInfo.source,
+    lastTokenSyncAt: new Date().toISOString(),
+  };
+  if (
+    forceStatus ||
+    current.accessToken !== next.accessToken ||
+    current.lastTokenSyncSource !== next.lastTokenSyncSource
+  ) {
+    await chrome.storage.sync.set({
+      accessToken: next.accessToken,
+      lastTokenSyncSource: next.lastTokenSyncSource,
+      lastTokenSyncAt: next.lastTokenSyncAt,
+    });
+  }
+  return next;
+}
+
+async function refreshAlarm(settings) {
+  await chrome.alarms.clear(ALARM_NAME);
+  if (!settings.taskPollingEnabled) {
+    return;
+  }
+  const minutes = Math.max(0.5, pollIntervalMs(settings) / 60000);
+  await chrome.alarms.create(ALARM_NAME, { delayInMinutes: minutes, periodInMinutes: minutes });
+}
+
+async function scheduleNextPoll(delayMs = null) {
+  if (pollTimer) {
+    clearTimeout(pollTimer);
+    pollTimer = null;
+  }
+  const settings = await getSettings();
+  if (!settings.taskPollingEnabled) {
+    return;
+  }
+  const ms = delayMs ?? pollIntervalMs(settings);
+  pollTimer = setTimeout(() => {
+    void pollOnce().catch((error) => console.warn("zncm task poll failed", error));
+  }, ms);
+}
+
+async function waitForTabLoad(tabId, timeoutSeconds) {
+  const timeoutMs = Math.max(5, Number(timeoutSeconds || 30)) * 1000;
+  try {
+    const tab = await chrome.tabs.get(tabId);
+    if (tab.status === "complete") {
+      return true;
+    }
+  } catch {
+    return false;
+  }
+
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      chrome.tabs.onUpdated.removeListener(listener);
+      resolve(false);
+    }, timeoutMs);
+
+    function listener(updatedTabId, changeInfo) {
+      if (updatedTabId === tabId && changeInfo.status === "complete") {
+        clearTimeout(timer);
+        chrome.tabs.onUpdated.removeListener(listener);
+        resolve(true);
+      }
+    }
+
+    chrome.tabs.onUpdated.addListener(listener);
+  });
+}
+
+async function captureFromTab(tabId, maxContentChars) {
+  const [result] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: deerExtractCurrentPage,
+  });
+  const page = result?.result;
+  if (!page?.content) {
+    throw new Error("当前页面没有可读取的文本。");
+  }
+  const limit = Math.max(1000, Number(maxContentChars || 200000));
+  if (page.content.length > limit) {
+    page.content = `${page.content.slice(0, limit)}\n\n[Truncated by zncm browser task limit]`;
+  }
+  return page;
+}
+
+async function postTaskResult(taskId, settings, payload) {
+  const apiBaseUrl = deerNormalizeBaseUrl(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  const response = await fetch(`${apiBaseUrl}/api/browser-context/tasks/${encodeURIComponent(taskId)}/result`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...deerAuthHeaders(settings),
+    },
+    body: JSON.stringify(payload),
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const detail = typeof data.detail === "string" ? data.detail : JSON.stringify(data.detail || data);
+    throw new Error(detail || `HTTP ${response.status}`);
+  }
+  return data;
+}
+
+function zncmApiBaseCandidates(settings) {
+  const candidates = [];
+  const add = (value) => {
+    const normalized = deerNormalizeBaseUrl(value || "");
+    if (normalized && !candidates.includes(normalized)) {
+      candidates.push(normalized);
+    }
+  };
+
+  add(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  try {
+    const url = new URL(deerNormalizeBaseUrl(settings.apiBaseUrl || ""));
+    if (url.pathname && url.pathname !== "/") {
+      add(url.origin);
+    }
+  } catch {
+    // Ignore invalid configured API URL.
+  }
+  add(DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  return candidates;
+}
+
+async function zncmFetchJson(settings, path, options) {
+  let lastError = null;
+  for (const apiBaseUrl of zncmApiBaseCandidates(settings)) {
+    try {
+      const response = await fetch(`${apiBaseUrl}${path}`, options);
+      const contentType = response.headers.get("content-type") || "";
+      const data = contentType.includes("application/json")
+        ? await response.json().catch(() => ({}))
+        : { detail: await response.text().catch(() => "") };
+      if (response.ok) {
+        return { data, apiBaseUrl, status: response.status };
+      }
+      const detail = typeof data.detail === "string" ? data.detail : JSON.stringify(data.detail || data);
+      lastError = new Error(detail || `HTTP ${response.status}`);
+      lastError.status = response.status;
+      lastError.detail = detail;
+      lastError.apiBaseUrl = apiBaseUrl;
+      if (response.status !== 404) {
+        throw lastError;
+      }
+    } catch (error) {
+      lastError = error;
+      if (error?.status && error.status !== 404) {
+        throw error;
+      }
+    }
+  }
+  throw lastError || new Error("zncm 服务请求失败。");
+}
+
+function zncmMakeThreadId() {
+  if (globalThis.crypto?.randomUUID) {
+    return globalThis.crypto.randomUUID();
+  }
+  return `zncm-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function zncmBuildPagePrompt(page, content, truncated, followUp) {
+  const title = page.title || "未知标题";
+  const url = page.url || "未知 URL";
+  const capturedAt = new Date().toISOString();
+  if (followUp) {
+    return [
+      "你是 zncm 页面问答助手。请继续基于本会话里已经读取的网页内容回答用户问题。",
+      "如果已有网页内容不足以回答，请说明缺少哪些信息；不要编造，也不要再尝试抓取其它网页。",
+      `当前页面标题：${title}`,
+      `当前页面 URL：${url}`,
+      `本轮提问时间：${capturedAt}`,
+    ].join("\n\n");
+  }
+
+  return [
+    "你是 zncm 页面问答助手。请直接基于当前网页内容回答用户问题。",
+    "如果网页内容不足以回答，请说明缺少哪些信息；不要编造，也不要再尝试抓取其它网页。",
+    `页面标题：${title}`,
+    `页面 URL：${url}`,
+    `读取时间：${capturedAt}`,
+    truncated ? "说明：页面内容较长，本次已按插件限制截断。" : "说明：页面内容如下。",
+    "当前网页内容：",
+    page.contentType === "text" ? `\`\`\`text\n${content}\n\`\`\`` : content,
+  ].join("\n\n");
+}
+
+function zncmExtractLatestAnswer(values) {
+  const messages = Array.isArray(values?.messages) ? values.messages : [];
+  for (let index = messages.length - 1; index >= 0; index -= 1) {
+    const message = messages[index] || {};
+    const type = String(message.type || message.role || "").toLowerCase();
+    if (type !== "ai" && type !== "assistant") {
+      continue;
+    }
+    const content = message.content;
+    if (typeof content === "string" && content.trim()) {
+      return content.trim();
+    }
+    if (Array.isArray(content)) {
+      const text = content
+        .map((part) => {
+          if (typeof part === "string") return part;
+          if (part && typeof part.text === "string") return part.text;
+          return "";
+        })
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+      if (text) {
+        return text;
+      }
+    }
+  }
+  return "";
+}
+
+async function askZncmViaRunsWait(settings, payload, page, question) {
+  const contentLimit = 60000;
+  const rawContent = String(page.content || "");
+  const truncated = rawContent.length > contentLimit;
+  const content = truncated ? `${rawContent.slice(0, contentLimit)}\n\n[Truncated locally by zncm Web Clipper]` : rawContent;
+  const threadId = payload.threadId || zncmMakeThreadId();
+  const promptPrefix = zncmBuildPagePrompt(page, content, truncated, Boolean(payload.threadId));
+  const { data } = await zncmFetchJson(settings, "/api/runs/wait", {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...deerAuthHeaders(settings),
+    },
+    body: JSON.stringify({
+      assistant_id: "lead_agent",
+      input: {
+        messages: [
+          {
+            type: "human",
+            content: question,
+            additional_kwargs: {
+              prompt_prefix: promptPrefix,
+            },
+          },
+        ],
+      },
+      config: {
+        configurable: {
+          thread_id: threadId,
+        },
+      },
+      metadata: {
+        source: "zncm_page_assistant",
+        browser_context_url: page.url || "",
+        browser_context_title: page.title || "",
+        browser_context_fallback: true,
+      },
+      stream_mode: ["values"],
+      on_disconnect: "continue",
+      multitask_strategy: "reject",
+    }),
+  });
+  return {
+    success: true,
+    thread_id: threadId,
+    run_id: "",
+    answer: zncmExtractLatestAnswer(data) || "zncm 没有返回可显示的答案。",
+    truncated,
+    message: "zncm 页面问答已完成。",
+  };
+}
+
+async function askZncmAboutPage(payload) {
+  let settings = await getSettings();
+  settings = await discoverServiceBases(settings);
+  settings = await syncAuthToken(settings);
+  if (!settings.pageAssistantEnabled) {
+    throw new Error("页面问答框已关闭。");
+  }
+
+  const page = payload?.page || {};
+  const question = String(payload?.question || "").trim();
+  if (!question) {
+    throw new Error("请输入要询问的问题。");
+  }
+  if (!page.content) {
+    throw new Error("当前页面没有可读取的正文。");
+  }
+
+  try {
+    const { data } = await zncmFetchJson(settings, "/api/browser-context/ask", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...deerAuthHeaders(settings),
+      },
+      body: JSON.stringify({
+        thread_id: payload.threadId || null,
+        title: page.title || "",
+        url: page.url || "",
+        content: page.content || "",
+        content_type: page.contentType || "markdown",
+        question,
+      }),
+    });
+    return data;
+  } catch (error) {
+    const detail = String(error?.detail || error?.message || "");
+    if (error?.status === 404 && !/browser context integration is disabled/i.test(detail)) {
+      return askZncmViaRunsWait(settings, payload, page, question);
+    }
+    throw error;
+  }
+}
+
+async function getActSessionMap() {
+  try {
+    const stored = await chrome.storage.session.get({ actSessions: {} });
+    return stored.actSessions && typeof stored.actSessions === "object" ? stored.actSessions : {};
+  } catch {
+    return {};
+  }
+}
+
+async function setActSessionTab(sessionId, tabId) {
+  if (!sessionId) return;
+  const map = await getActSessionMap();
+  map[sessionId] = tabId;
+  await chrome.storage.session.set({ actSessions: map }).catch(() => {});
+}
+
+async function removeActSession(sessionId) {
+  if (!sessionId) return;
+  const map = await getActSessionMap();
+  if (sessionId in map) {
+    delete map[sessionId];
+    await chrome.storage.session.set({ actSessions: map }).catch(() => {});
+  }
+}
+
+async function resolveSessionTabId(sessionId) {
+  const map = await getActSessionMap();
+  const tabId = map[sessionId];
+  if (!tabId) return null;
+  try {
+    await chrome.tabs.get(tabId);
+    return tabId;
+  } catch {
+    await removeActSession(sessionId);
+    return null;
+  }
+}
+
+async function performActionInTab(tabId, action) {
+  const [result] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: deerPerformAction,
+    args: [action],
+  });
+  return result?.result || { status: "ok", message: "" };
+}
+
+async function observeTab(tabId, maxElements) {
+  const [result] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: deerObservePage,
+    args: [maxElements],
+  });
+  const observation = result?.result;
+  if (!observation) {
+    throw new Error("当前页面无法读取交互元素。");
+  }
+  return observation;
+}
+
+async function runActTask(task, settings) {
+  const sessionId = task.session_id || "";
+  const action = task.action || {};
+  const actionType = String(action.type || "").toLowerCase();
+  const maxElements = 150;
+
+  try {
+    if (!sessionId) {
+      throw new Error("act 任务缺少 session_id。");
+    }
+
+    if (actionType === "close") {
+      const tabId = await resolveSessionTabId(sessionId);
+      if (tabId) {
+        await chrome.tabs.remove(tabId).catch(() => {});
+      }
+      await removeActSession(sessionId);
+      await postTaskResult(task.id, settings, {
+        kind: "act",
+        observation: { action_status: "ok", message: "Tab closed.", url: "", title: "", elements: [], text: "" },
+        metadata: { source: "zncm-web-clipper", worker_id: settings.workerId, session_id: sessionId },
+      });
+      return;
+    }
+
+    let tabId = await resolveSessionTabId(sessionId);
+
+    if (actionType === "navigate") {
+      const url = String(action.url || task.url || "");
+      if (!url) {
+        throw new Error("navigate 动作缺少 url。");
+      }
+      if (tabId) {
+        await chrome.tabs.update(tabId, { url });
+      } else {
+        const tab = await chrome.tabs.create({ url, active: false });
+        tabId = tab.id;
+        await setActSessionTab(sessionId, tabId);
+      }
+      await waitForTabLoad(tabId, settings.taskPageLoadTimeoutSeconds);
+      await delay(800);
+    } else {
+      if (!tabId) {
+        throw new Error("会话标签页不存在，请先用 navigate 打开页面。");
+      }
+      const outcome = await performActionInTab(tabId, action);
+      // Give the page a moment to react / navigate, then settle.
+      await delay(400);
+      await waitForTabLoad(tabId, settings.taskPageLoadTimeoutSeconds);
+      await delay(500);
+      if (outcome.status === "error") {
+        const observation = await observeTab(tabId, maxElements).catch(() => ({ elements: [], text: "", url: "", title: "" }));
+        await postTaskResult(task.id, settings, {
+          kind: "act",
+          observation: { ...observation, action_status: outcome.status, message: outcome.message },
+          metadata: { source: "zncm-web-clipper", worker_id: settings.workerId, session_id: sessionId },
+        });
+        return;
+      }
+    }
+
+    const observation = await observeTab(tabId, maxElements);
+    await postTaskResult(task.id, settings, {
+      kind: "act",
+      title: observation.title || "",
+      url: observation.url || "",
+      observation: { ...observation, action_status: "ok", message: "" },
+      metadata: { source: "zncm-web-clipper", worker_id: settings.workerId, session_id: sessionId },
+    });
+  } catch (error) {
+    await postTaskResult(task.id, settings, {
+      kind: "act",
+      error: error instanceof Error ? error.message : String(error),
+      metadata: { source: "zncm-web-clipper", worker_id: settings.workerId, session_id: sessionId },
+    }).catch((submitError) => console.warn("Failed to submit zncm act task error", submitError));
+  }
+}
+
+async function runFetchTask(task, settings) {
+  let tabId = null;
+  try {
+    const tab = await chrome.tabs.create({ url: task.url, active: false });
+    tabId = tab.id;
+    await waitForTabLoad(tabId, settings.taskPageLoadTimeoutSeconds);
+    await delay(750);
+    const page = await captureFromTab(tabId, task.max_content_chars);
+    await postTaskResult(task.id, settings, {
+      kind: "fetch",
+      title: page.title,
+      url: page.url,
+      content: page.content,
+      content_type: page.contentType || "markdown",
+      metadata: {
+        source: "zncm-web-clipper",
+        worker_id: settings.workerId,
+        instruction: task.instruction || "",
+      },
+    });
+  } catch (error) {
+    await postTaskResult(task.id, settings, {
+      kind: "fetch",
+      error: error instanceof Error ? error.message : String(error),
+      metadata: {
+        source: "zncm-web-clipper",
+        worker_id: settings.workerId,
+      },
+    }).catch((submitError) => console.warn("Failed to submit zncm task error", submitError));
+  } finally {
+    if (tabId && settings.closeTaskTabs) {
+      await chrome.tabs.remove(tabId).catch(() => {});
+    }
+  }
+}
+
+async function runTask(task, settings) {
+  if ((task.kind || "fetch") === "act") {
+    await runActTask(task, settings);
+    return;
+  }
+  await runFetchTask(task, settings);
+}
+
+async function pollOnce() {
+  if (isPolling) {
+    return { ok: true, message: "任务轮询正在运行。" };
+  }
+
+  isPolling = true;
+  try {
+    let settings = await getSettings();
+    settings = await discoverServiceBases(settings);
+    settings = await syncAuthToken(settings);
+    if (!settings.taskPollingEnabled) {
+      return { ok: false, message: "任务轮询已关闭。" };
+    }
+
+    const apiBaseUrl = deerNormalizeBaseUrl(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+    const url = `${apiBaseUrl}/api/browser-context/tasks/next?worker_id=${encodeURIComponent(settings.workerId)}`;
+    const response = await fetch(url, { headers: deerAuthHeaders(settings) });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      const detail = typeof data.detail === "string" ? data.detail : JSON.stringify(data.detail || data);
+      throw new Error(detail || `HTTP ${response.status}`);
+    }
+    if (!data.task) {
+      return { ok: true, message: "暂无待处理的 zncm 浏览器任务。" };
+    }
+
+    await runTask(data.task, settings);
+    return { ok: true, message: `已完成 zncm 浏览器任务 ${data.task.id}。` };
+  } finally {
+    isPolling = false;
+    await scheduleNextPoll();
+  }
+}
+
+async function startup() {
+  let settings = await getSettings();
+  settings = await discoverServiceBases(settings);
+  settings = await syncAuthToken(settings);
+  await refreshAlarm(settings);
+  await scheduleNextPoll(1000);
+}
+
+chrome.runtime.onInstalled.addListener(() => void startup());
+chrome.runtime.onStartup.addListener(() => void startup());
+chrome.storage.onChanged.addListener((changes, areaName) => {
+  if (areaName === "sync") {
+    void startup();
+  }
+});
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === ALARM_NAME) {
+    void pollOnce().catch((error) => console.warn("zncm alarm poll failed", error));
+  }
+});
+chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+  if (message?.type === "zncm-discover-service") {
+    getSettings()
+      .then((settings) => discoverServiceBases(settings, true))
+      .then((settings) =>
+        sendResponse({
+          ok: Boolean(settings.apiBaseUrl && settings.webBaseUrl),
+          message: `服务地址：${settings.webBaseUrl}；API：${settings.apiBaseUrl}`,
+          apiBaseUrl: settings.apiBaseUrl,
+          webBaseUrl: settings.webBaseUrl,
+          source: settings.lastServiceSyncSource || "",
+        }),
+      )
+      .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    return true;
+  }
+
+  if (message?.type === "zncm-sync-token") {
+    syncAuthToken(null, true)
+      .then((settings) => {
+        const hasToken = Boolean(settings.accessToken);
+        sendResponse({
+          ok: hasToken,
+          message: hasToken
+            ? `Token 已从 ${settings.lastTokenSyncSource || "zncm"} 同步。`
+            : "没有找到 zncm token。请打开已登录的 zncm 页面后重试。",
+          source: settings.lastTokenSyncSource || "",
+        });
+      })
+      .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    return true;
+  }
+
+  if (message?.type === "zncm-page-agent-ask") {
+    askZncmAboutPage(message)
+      .then((result) => sendResponse({ ok: true, ...result }))
+      .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    return true;
+  }
+
+  if (message?.type === "zncm-open-options") {
+    chrome.runtime.openOptionsPage()
+      .then(() => sendResponse({ ok: true }))
+      .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+    return true;
+  }
+
+  if (message?.type !== "zncm-poll-now") {
+    return false;
+  }
+  pollOnce()
+    .then((result) => sendResponse(result))
+    .catch((error) => sendResponse({ ok: false, message: error instanceof Error ? error.message : String(error) }));
+  return true;
+});
+
+void startup();

browser-extension/deer-web-clipper/config.js

@@ -0,0 +1,9 @@
+// Default deployment settings for zncm Web Clipper.
+//
+// Change these two values before loading or packaging the extension when the
+// zncm service address changes. Users can still override them in the extension
+// settings page after installation.
+globalThis.ZNCM_WEB_CLIPPER_CONFIG = Object.freeze({
+  defaultWebBaseUrl: "http://47.94.209.59:2026",
+  defaultApiBaseUrl: "http://47.94.209.59:2026",
+});

browser-extension/deer-web-clipper/content.js

@@ -0,0 +1,737 @@
+(() => {
+  if (window.top !== window || window.__zncmPageAssistantLoaded) {
+    return;
+  }
+  window.__zncmPageAssistantLoaded = true;
+
+  const HOST_ID = "zncm-page-assistant-host";
+  const state = {
+    enabled: true,
+    open: false,
+    busy: false,
+    threadId: "",
+    pageUrl: location.href,
+    messages: [],
+  };
+
+  let host = null;
+  let shadow = null;
+  let ui = {};
+
+  function sendRuntimeMessage(message) {
+    return new Promise((resolve, reject) => {
+      chrome.runtime.sendMessage(message, (response) => {
+        const error = chrome.runtime.lastError;
+        if (error) {
+          reject(new Error(error.message));
+          return;
+        }
+        resolve(response || {});
+      });
+    });
+  }
+
+  function makeElement(tag, className = "", text = "") {
+    const element = document.createElement(tag);
+    if (className) {
+      element.className = className;
+    }
+    if (text) {
+      element.textContent = text;
+    }
+    return element;
+  }
+
+  function setStatus(message) {
+    if (ui.status) {
+      ui.status.textContent = message || "";
+    }
+  }
+
+  function setBusy(busy) {
+    state.busy = busy;
+    if (ui.send) ui.send.disabled = busy;
+    if (ui.input) ui.input.disabled = busy;
+    if (ui.panel) ui.panel.classList.toggle("is-busy", busy);
+  }
+
+  function resetThreadIfPageChanged() {
+    if (state.pageUrl === location.href) {
+      return;
+    }
+    state.pageUrl = location.href;
+    state.threadId = "";
+    state.messages = [];
+    renderMessages();
+    setStatus("页面已变化，下一次提问会重新读取当前页面。");
+  }
+
+  function destroyWidget() {
+    if (host) {
+      host.remove();
+    }
+    host = null;
+    shadow = null;
+    ui = {};
+  }
+
+  function renderMessages() {
+    if (!ui.messages) {
+      return;
+    }
+    ui.messages.replaceChildren();
+    if (state.messages.length === 0) {
+      const empty = makeElement("div", "empty");
+      const emptyTitle = makeElement("strong", "", "问问当前页面");
+      const emptyText = makeElement("span", "", "可以提问页面里的数据、表格、段落和结论。");
+      empty.append(emptyTitle, emptyText);
+      ui.messages.appendChild(empty);
+      return;
+    }
+
+    for (const message of state.messages) {
+      const item = makeElement("div", `message ${message.role}`);
+      const avatar = makeElement("div", "avatar", message.role === "user" ? "你" : "zn");
+      const bubble = makeElement("div", "bubble");
+      const label = makeElement("div", "message-label", message.role === "user" ? "你" : "zncm");
+      const body = makeElement("div", "message-body", message.text);
+      if (message.pending) {
+        body.classList.add("pending");
+      }
+      bubble.append(label, body);
+      item.append(avatar, bubble);
+      ui.messages.appendChild(item);
+    }
+    ui.messages.scrollTop = ui.messages.scrollHeight;
+  }
+
+  function setOpen(open) {
+    state.open = open;
+    if (!ui.panel || !ui.launcher) {
+      return;
+    }
+    ui.panel.classList.toggle("open", open);
+    ui.launcher.classList.toggle("open", open);
+    ui.launcher.setAttribute("aria-expanded", String(open));
+    if (open) {
+      resetThreadIfPageChanged();
+      setTimeout(() => ui.input?.focus(), 50);
+    }
+  }
+
+  async function ask(question) {
+    const normalized = String(question || "").trim();
+    if (!normalized || state.busy) {
+      return;
+    }
+
+    resetThreadIfPageChanged();
+    setBusy(true);
+    setStatus("正在读取页面并发送给 zncm...");
+    state.messages.push({ role: "user", text: normalized });
+    const pending = { role: "assistant", text: "zncm 正在理解当前页面...", pending: true };
+    state.messages.push(pending);
+    renderMessages();
+    ui.input.value = "";
+
+    try {
+      if (typeof deerExtractCurrentPage !== "function") {
+        throw new Error("页面读取脚本未加载，请刷新当前页面后重试。");
+      }
+      const page = deerExtractCurrentPage();
+      const response = await sendRuntimeMessage({
+        type: "zncm-page-agent-ask",
+        page,
+        question: normalized,
+        threadId: state.threadId || "",
+      });
+      if (!response.ok) {
+        throw new Error(response.message || "zncm 没有返回答案。");
+      }
+      state.threadId = response.thread_id || state.threadId;
+      pending.text = response.answer || "zncm 没有返回答案。";
+      pending.pending = false;
+      setStatus(response.truncated ? "已回答。页面内容较长，本次按配置做了截断。" : "已回答。");
+    } catch (error) {
+      pending.text = error instanceof Error ? error.message : "页面问答失败。";
+      pending.pending = false;
+      setStatus("本次问答失败。");
+    } finally {
+      setBusy(false);
+      renderMessages();
+      ui.input.focus();
+    }
+  }
+
+  function buildWidget() {
+    host = document.createElement("div");
+    host.id = HOST_ID;
+    document.documentElement.appendChild(host);
+    shadow = host.attachShadow({ mode: "open" });
+
+    const style = document.createElement("style");
+    style.textContent = `
+      :host {
+        all: initial;
+        color-scheme: light;
+        font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+
+      .launcher,
+      .panel {
+        position: fixed;
+        z-index: 2147483647;
+        font: 14px/1.45 Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+      }
+
+      .launcher {
+        right: 20px;
+        bottom: 20px;
+        display: grid;
+        grid-template-columns: auto 1fr;
+        align-items: center;
+        gap: 8px;
+        height: 44px;
+        min-width: 112px;
+        border: 1px solid rgba(15, 118, 110, 0.28);
+        border-radius: 8px;
+        padding: 0 12px 0 10px;
+        background: #0f766e;
+        color: #fff;
+        box-shadow: 0 12px 34px rgba(15, 118, 110, 0.28), 0 2px 8px rgba(17, 24, 39, 0.12);
+        cursor: pointer;
+        font-weight: 750;
+        transition: transform 160ms ease, box-shadow 160ms ease, background 160ms ease;
+      }
+
+      .launcher:hover {
+        transform: translateY(-2px);
+        box-shadow: 0 16px 40px rgba(15, 118, 110, 0.32), 0 4px 12px rgba(17, 24, 39, 0.14);
+      }
+
+      .launcher-mark {
+        display: grid;
+        place-items: center;
+        width: 24px;
+        height: 24px;
+        border-radius: 7px;
+        background: rgba(255, 255, 255, 0.18);
+        font-size: 12px;
+        letter-spacing: 0;
+        box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.2);
+      }
+
+      .launcher.open {
+        background: #115e59;
+      }
+
+      .panel {
+        right: 20px;
+        bottom: 72px;
+        width: min(430px, calc(100vw - 24px));
+        max-height: min(640px, calc(100vh - 96px));
+        display: none;
+        grid-template-rows: auto auto minmax(180px, 1fr) auto;
+        overflow: hidden;
+        border: 1px solid #d6d8dc;
+        border-radius: 8px;
+        background: #ffffff;
+        color: #171717;
+        box-shadow: 0 24px 70px rgba(17, 24, 39, 0.2), 0 1px 2px rgba(17, 24, 39, 0.08);
+      }
+
+      .panel.open {
+        display: grid;
+        animation: zncm-panel-in 160ms ease-out;
+      }
+
+      @keyframes zncm-panel-in {
+        from {
+          opacity: 0;
+          transform: translateY(8px) scale(0.985);
+        }
+        to {
+          opacity: 1;
+          transform: translateY(0) scale(1);
+        }
+      }
+
+      .header {
+        display: grid;
+        gap: 10px;
+        padding: 14px;
+        background: linear-gradient(180deg, #f4fffc 0%, #ffffff 84%);
+        border-bottom: 1px solid #e5e7eb;
+      }
+
+      .header-top {
+        display: flex;
+        align-items: center;
+        justify-content: space-between;
+        gap: 12px;
+      }
+
+      .brand {
+        display: flex;
+        align-items: center;
+        min-width: 0;
+        gap: 10px;
+      }
+
+      .brand-mark {
+        display: grid;
+        place-items: center;
+        width: 34px;
+        height: 34px;
+        flex: 0 0 auto;
+        border-radius: 8px;
+        background: #0f766e;
+        color: #fff;
+        font-weight: 800;
+        box-shadow: 0 8px 20px rgba(15, 118, 110, 0.18);
+      }
+
+      .brand-copy {
+        display: grid;
+        min-width: 0;
+        gap: 1px;
+      }
+
+      .brand-copy strong {
+        color: #111827;
+        font-size: 15px;
+        line-height: 1.25;
+      }
+
+      .brand-copy span {
+        overflow: hidden;
+        color: #6b7280;
+        font-size: 12px;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .header-actions {
+        display: flex;
+        flex: 0 0 auto;
+        gap: 6px;
+      }
+
+      .icon-button {
+        display: grid;
+        place-items: center;
+        width: auto;
+        min-width: 34px;
+        height: 30px;
+        padding: 0 8px;
+        border: 1px solid #dfe3e8;
+        border-radius: 7px;
+        background: #fff;
+        color: #374151;
+        cursor: pointer;
+        font: inherit;
+        font-size: 12px;
+        white-space: nowrap;
+        transition: background 140ms ease, border-color 140ms ease, color 140ms ease;
+      }
+
+      .icon-button:hover {
+        border-color: #0f766e;
+        color: #0f766e;
+        background: #f0fdfa;
+      }
+
+      .page-chip {
+        display: grid;
+        grid-template-columns: auto 1fr;
+        align-items: center;
+        gap: 8px;
+        min-width: 0;
+        border: 1px solid #dbeafe;
+        border-radius: 8px;
+        padding: 8px 10px;
+        background: #f8fbff;
+        color: #334155;
+        box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.8);
+      }
+
+      .page-chip-dot {
+        width: 8px;
+        height: 8px;
+        border-radius: 999px;
+        background: #0f766e;
+      }
+
+      .page-chip-text {
+        overflow: hidden;
+        font-size: 12px;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+      }
+
+      .status {
+        min-height: 20px;
+        padding: 9px 14px;
+        border-bottom: 1px solid #f0f2f5;
+        color: #475569;
+        background: #fbfcfd;
+        font-size: 12px;
+      }
+
+      .messages {
+        display: grid;
+        align-content: start;
+        gap: 12px;
+        overflow: auto;
+        padding: 14px;
+        background: linear-gradient(180deg, #f7f8fa 0%, #f3f6f8 100%);
+      }
+
+      .empty {
+        display: grid;
+        gap: 5px;
+        padding: 16px;
+        border: 1px solid #dfe7ed;
+        border-radius: 8px;
+        background: linear-gradient(180deg, #ffffff 0%, #fbfefd 100%);
+        color: #4b5563;
+        box-shadow: 0 8px 20px rgba(15, 23, 42, 0.04);
+      }
+
+      .empty strong {
+        color: #111827;
+        font-size: 14px;
+      }
+
+      .empty span {
+        font-size: 13px;
+      }
+
+      .message {
+        display: grid;
+        grid-template-columns: 28px minmax(0, 1fr);
+        gap: 8px;
+        align-items: start;
+      }
+
+      .message.user {
+        grid-template-columns: minmax(0, 1fr) 28px;
+      }
+
+      .message.user .avatar {
+        grid-column: 2;
+      }
+
+      .message.user .bubble {
+        grid-column: 1;
+        justify-self: end;
+      }
+
+      .avatar {
+        display: grid;
+        place-items: center;
+        width: 28px;
+        height: 28px;
+        border-radius: 8px;
+        background: #e6fffb;
+        color: #0f766e;
+        font-size: 11px;
+        font-weight: 800;
+      }
+
+      .message.user .avatar {
+        background: #111827;
+        color: #fff;
+      }
+
+      .bubble {
+        display: grid;
+        gap: 4px;
+        max-width: 100%;
+      }
+
+      .message-label {
+        color: #6b7280;
+        font-size: 11px;
+      }
+
+      .message.user .message-label {
+        text-align: right;
+      }
+
+      .message-body {
+        max-width: 330px;
+        padding: 10px 12px;
+        border: 1px solid #e5e7eb;
+        border-radius: 8px;
+        background: #fff;
+        color: #171717;
+        white-space: pre-wrap;
+        overflow-wrap: anywhere;
+        box-shadow: 0 1px 2px rgba(15, 23, 42, 0.04);
+      }
+
+      .message.user .message-body {
+        border-color: #0f172a;
+        background: #0f172a;
+        color: #fff;
+      }
+
+      .message-body.pending {
+        color: #6b7280;
+      }
+
+      .message-body.pending::after {
+        content: "";
+        display: inline-block;
+        width: 18px;
+        height: 4px;
+        margin-left: 6px;
+        border-radius: 999px;
+        background: linear-gradient(90deg, #0f766e 0 33%, transparent 33% 100%);
+        background-size: 9px 4px;
+        animation: zncm-thinking 900ms linear infinite;
+        vertical-align: middle;
+      }
+
+      @keyframes zncm-thinking {
+        from {
+          background-position: 0 0;
+        }
+        to {
+          background-position: 18px 0;
+        }
+      }
+
+      .composer-wrap {
+        display: grid;
+        gap: 10px;
+        padding: 12px 14px 14px;
+        background: #fff;
+        border-top: 1px solid #e5e7eb;
+      }
+
+      .quick {
+        display: grid;
+        grid-template-columns: repeat(2, minmax(0, 1fr));
+        gap: 7px;
+      }
+
+      .quick button {
+        border: 1px solid #d6d8dc;
+        border-radius: 8px;
+        padding: 8px 10px;
+        background: #fbfcfd;
+        color: #374151;
+        cursor: pointer;
+        font: inherit;
+        font-size: 12px;
+        text-align: left;
+        transition: background 140ms ease, border-color 140ms ease, color 140ms ease, transform 140ms ease;
+      }
+
+      .quick button:hover {
+        border-color: #0f766e;
+        color: #0f766e;
+        background: #f0fdfa;
+        transform: translateY(-1px);
+      }
+
+      .composer {
+        display: grid;
+        grid-template-columns: 1fr auto;
+        gap: 8px;
+        align-items: end;
+      }
+
+      .composer textarea {
+        min-height: 46px;
+        max-height: 130px;
+        resize: vertical;
+        border: 1px solid #cfd6dd;
+        border-radius: 8px;
+        padding: 10px 11px;
+        color: #171717;
+        background: #fbfcfd;
+        font: inherit;
+        outline: none;
+      }
+
+      .composer textarea:focus {
+        border-color: #0f766e;
+        box-shadow: 0 0 0 3px rgba(15, 118, 110, 0.12);
+      }
+
+      .composer button {
+        height: 42px;
+        border: 0;
+        border-radius: 8px;
+        padding: 0 14px;
+        background: #0f766e;
+        color: #fff;
+        cursor: pointer;
+        font: inherit;
+        font-weight: 750;
+        box-shadow: 0 8px 18px rgba(15, 118, 110, 0.2);
+        transition: transform 140ms ease, background 140ms ease, box-shadow 140ms ease;
+      }
+
+      .composer button:hover {
+        background: #115e59;
+        transform: translateY(-1px);
+        box-shadow: 0 10px 22px rgba(15, 118, 110, 0.24);
+      }
+
+      .panel.is-busy .brand-mark,
+      .panel.is-busy .launcher-mark {
+        opacity: 0.82;
+      }
+
+      .composer button:disabled,
+      .quick button:disabled,
+      .icon-button:disabled {
+        cursor: not-allowed;
+        opacity: 0.6;
+      }
+
+      @media (max-width: 480px) {
+        .launcher {
+          right: 12px;
+          bottom: 12px;
+          min-width: 96px;
+        }
+
+        .panel {
+          right: 12px;
+          bottom: 64px;
+          width: calc(100vw - 24px);
+          max-height: calc(100vh - 80px);
+        }
+
+        .message-body {
+          max-width: calc(100vw - 104px);
+        }
+
+        .quick {
+          grid-template-columns: 1fr;
+        }
+      }
+    `;
+
+    const launcher = makeElement("button", "launcher");
+    launcher.type = "button";
+    launcher.title = "打开 zncm 页面问答";
+    launcher.setAttribute("aria-expanded", "false");
+    launcher.append(makeElement("span", "launcher-mark", "zn"), makeElement("span", "", "页面问答"));
+
+    const panel = makeElement("section", "panel");
+    const header = makeElement("header", "header");
+    const headerTop = makeElement("div", "header-top");
+    const brand = makeElement("div", "brand");
+    const brandCopy = makeElement("div", "brand-copy");
+    const title = makeElement("strong", "", "zncm 页面问答");
+    const subtitle = makeElement("span", "", "读取当前页面并回答");
+    brandCopy.append(title, subtitle);
+    brand.append(makeElement("div", "brand-mark", "zn"), brandCopy);
+
+    const actions = makeElement("div", "header-actions");
+    const settings = makeElement("button", "icon-button", "设置");
+    settings.type = "button";
+    settings.title = "打开插件设置";
+    const minimize = makeElement("button", "icon-button", "－");
+    minimize.type = "button";
+    minimize.title = "收起";
+    actions.append(settings, minimize);
+    headerTop.append(brand, actions);
+
+    const pageChip = makeElement("div", "page-chip");
+    const pageTitle = makeElement("span", "page-chip-text", document.title || location.hostname);
+    pageChip.append(makeElement("span", "page-chip-dot"), pageTitle);
+    header.append(headerTop, pageChip);
+
+    const status = makeElement("div", "status", "已连接当前页面。");
+    const messages = makeElement("div", "messages");
+
+    const composerWrap = makeElement("div", "composer-wrap");
+    const quick = makeElement("div", "quick");
+    for (const text of ["总结此页", "提取关键数据", "列出待办", "解释表格"]) {
+      const chip = makeElement("button", "", text);
+      chip.type = "button";
+      chip.addEventListener("click", () => ask(text));
+      quick.appendChild(chip);
+    }
+
+    const composer = makeElement("form", "composer");
+    const input = makeElement("textarea");
+    input.placeholder = "问当前页面...";
+    input.rows = 2;
+    const send = makeElement("button", "", "发送");
+    send.type = "submit";
+    composer.append(input, send);
+    composerWrap.append(quick, composer);
+
+    panel.append(header, status, messages, composerWrap);
+    shadow.append(style, panel, launcher);
+
+    ui = { launcher, panel, subtitle, pageTitle, status, messages, input, send };
+    renderMessages();
+
+    launcher.addEventListener("click", () => setOpen(!state.open));
+    minimize.addEventListener("click", () => setOpen(false));
+    settings.addEventListener("click", () => {
+      sendRuntimeMessage({ type: "zncm-open-options" }).catch((error) => {
+        setStatus(error instanceof Error ? error.message : "无法打开插件设置。");
+      });
+    });
+    composer.addEventListener("submit", (event) => {
+      event.preventDefault();
+      ask(input.value);
+    });
+    input.addEventListener("keydown", (event) => {
+      if (event.key === "Enter" && !event.shiftKey) {
+        event.preventDefault();
+        ask(input.value);
+      }
+    });
+  }
+
+  function ensureWidget() {
+    if (!state.enabled) {
+      destroyWidget();
+      return;
+    }
+    if (document.getElementById(HOST_ID)) {
+      return;
+    }
+    buildWidget();
+  }
+
+  async function loadSettings() {
+    const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+    state.enabled = Boolean(settings.pageAssistantEnabled);
+    ensureWidget();
+  }
+
+  chrome.storage.onChanged.addListener((changes, areaName) => {
+    if (areaName !== "sync" || !changes.pageAssistantEnabled) {
+      return;
+    }
+    state.enabled = Boolean(changes.pageAssistantEnabled.newValue);
+    ensureWidget();
+    if (state.enabled) {
+      setStatus("页面问答框已开启。");
+    }
+  });
+
+  setInterval(() => {
+    if (!state.enabled || !ui.pageTitle) {
+      return;
+    }
+    if (state.pageUrl !== location.href) {
+      resetThreadIfPageChanged();
+    }
+    ui.pageTitle.textContent = document.title || location.hostname;
+  }, 1200);
+
+  void loadSettings();
+})();

browser-extension/deer-web-clipper/manifest.json

@@ -0,0 +1,24 @@
+{
+  "manifest_version": 3,
+  "name": "zncm Web Clipper",
+  "version": "0.2.0",
+  "description": "Send pages to zncm and execute browser-backed fetch tasks.",
+  "permissions": ["activeTab", "alarms", "cookies", "scripting", "storage", "tabs"],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js"
+  },
+  "action": {
+    "default_title": "zncm Web Clipper",
+    "default_popup": "popup.html"
+  },
+  "options_page": "options.html",
+  "content_scripts": [
+    {
+      "matches": ["http://*/*", "https://*/*"],
+      "js": ["config.js", "shared.js", "content.js"],
+      "run_at": "document_idle",
+      "all_frames": false
+    }
+  ]
+}

browser-extension/deer-web-clipper/options.html

@@ -0,0 +1,74 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <title>zncm Web Clipper Settings</title>
+    <link rel="stylesheet" href="styles.css" />
+  </head>
+  <body>
+    <main class="options">
+      <h1>zncm Web Clipper Settings</h1>
+      <label>
+        API 地址
+        <input id="apiBaseUrl" />
+      </label>
+      <label>
+        前端地址
+        <input id="webBaseUrl" />
+      </label>
+      <label class="checkbox">
+        <input id="autoDiscoverServiceUrl" type="checkbox" />
+        自动识别已打开 zncm 页面的服务地址
+      </label>
+      <div class="actions">
+        <button id="discoverService" type="button">重新识别服务地址</button>
+      </div>
+      <p id="serviceStatus" class="status"></p>
+      <label>
+        Access Token
+        <textarea id="accessToken" rows="5" placeholder="会自动从已登录 zncm 页面或 access_token Cookie 获取。也可以手动粘贴。"></textarea>
+      </label>
+      <label class="checkbox">
+        <input id="tokenSyncEnabled" type="checkbox" />
+        自动同步已登录 zncm 的 token
+      </label>
+      <div class="actions">
+        <button id="syncToken" type="button">Sync token now</button>
+      </div>
+      <p id="tokenStatus" class="status"></p>
+      <label class="checkbox">
+        <input id="pageAssistantEnabled" type="checkbox" />
+        启用页面问答框
+      </label>
+      <label>
+        默认首问
+        <textarea id="defaultPrompt" rows="4"></textarea>
+      </label>
+      <label class="checkbox">
+        <input id="taskPollingEnabled" type="checkbox" />
+        启用 zncm 聊天触发的浏览器抓取任务
+      </label>
+      <label>
+        Worker ID
+        <input id="workerId" placeholder="自动生成" />
+      </label>
+      <label>
+        任务轮询间隔秒数
+        <input id="taskPollIntervalSeconds" type="number" min="3" step="1" />
+      </label>
+      <label>
+        页面加载超时秒数
+        <input id="taskPageLoadTimeoutSeconds" type="number" min="5" step="1" />
+      </label>
+      <label class="checkbox">
+        <input id="closeTaskTabs" type="checkbox" />
+        抓取完成后关闭任务标签页
+      </label>
+      <button id="save" type="button">保存</button>
+      <p id="status" class="status"></p>
+    </main>
+    <script src="config.js"></script>
+    <script src="shared.js"></script>
+    <script src="options.js"></script>
+  </body>
+</html>

browser-extension/deer-web-clipper/options.js

@@ -0,0 +1,148 @@
+const textFields = [
+  "apiBaseUrl",
+  "webBaseUrl",
+  "accessToken",
+  "defaultPrompt",
+  "workerId",
+  "taskPollIntervalSeconds",
+  "taskPageLoadTimeoutSeconds",
+];
+const checkboxFields = [
+  "autoDiscoverServiceUrl",
+  "tokenSyncEnabled",
+  "pageAssistantEnabled",
+  "taskPollingEnabled",
+  "closeTaskTabs",
+];
+
+function formatServiceStatus(settings) {
+  if (!settings.lastServiceSyncAt) {
+    return `当前服务地址：${settings.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl}；API：${settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl}`;
+  }
+  return `当前服务地址：${settings.webBaseUrl || ""}；API：${settings.apiBaseUrl || ""}\n上次识别：${settings.lastServiceSyncAt}（${settings.lastServiceSyncSource || "unknown source"}）`;
+}
+
+function formatTokenStatus(settings) {
+  if (!settings.lastTokenSyncAt) {
+    return "Token 尚未自动同步。";
+  }
+  return `上次 token 同步：${settings.lastTokenSyncAt}（${settings.lastTokenSyncSource || "unknown source"}）`;
+}
+
+async function loadSettings() {
+  const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+  if (!settings.workerId) {
+    settings.workerId = deerMakeWorkerId();
+    await chrome.storage.sync.set({ workerId: settings.workerId });
+  }
+  document.getElementById("apiBaseUrl").placeholder =
+    DEER_CLIPPER_DEFAULTS.apiBaseUrl || "在 config.js 中配置默认 API 地址";
+  document.getElementById("webBaseUrl").placeholder =
+    DEER_CLIPPER_DEFAULTS.webBaseUrl || "在 config.js 中配置默认前端地址";
+  for (const field of textFields) {
+    document.getElementById(field).value = settings[field] ?? "";
+  }
+  for (const field of checkboxFields) {
+    document.getElementById(field).checked = Boolean(settings[field]);
+  }
+  document.getElementById("serviceStatus").textContent = formatServiceStatus(settings);
+  document.getElementById("tokenStatus").textContent = formatTokenStatus(settings);
+}
+
+async function saveSettings() {
+  const next = {};
+  for (const field of textFields) {
+    next[field] = document.getElementById(field).value.trim();
+  }
+  for (const field of checkboxFields) {
+    next[field] = document.getElementById(field).checked;
+  }
+  next.apiBaseUrl = deerNormalizeBaseUrl(next.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  next.webBaseUrl = deerNormalizeBaseUrl(next.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl);
+  next.defaultPrompt = next.defaultPrompt || DEER_CLIPPER_DEFAULT_PROMPT;
+  next.workerId = next.workerId || deerMakeWorkerId();
+  next.taskPollIntervalSeconds = Math.max(3, Number(next.taskPollIntervalSeconds || DEER_CLIPPER_DEFAULTS.taskPollIntervalSeconds));
+  next.taskPageLoadTimeoutSeconds = Math.max(5, Number(next.taskPageLoadTimeoutSeconds || DEER_CLIPPER_DEFAULTS.taskPageLoadTimeoutSeconds));
+  await chrome.storage.sync.set(next);
+  const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+  document.getElementById("status").textContent = "已保存。";
+  document.getElementById("serviceStatus").textContent = formatServiceStatus(settings);
+  document.getElementById("tokenStatus").textContent = formatTokenStatus(settings);
+}
+
+function sendDiscoverServiceMessage() {
+  return new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage({ type: "zncm-discover-service" }, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(response || { ok: false, message: "服务地址识别没有返回结果。" });
+    });
+  });
+}
+
+function sendSyncTokenMessage() {
+  return new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage({ type: "zncm-sync-token" }, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+      reject(new Error(error.message));
+        return;
+      }
+      resolve(response || { ok: false, message: "Token 同步没有返回结果。" });
+    });
+  });
+}
+
+async function discoverServiceNow() {
+  const button = document.getElementById("discoverService");
+  button.disabled = true;
+  document.getElementById("serviceStatus").textContent = "正在识别服务地址...";
+  try {
+    await chrome.storage.sync.set({
+      autoDiscoverServiceUrl: document.getElementById("autoDiscoverServiceUrl").checked,
+      apiBaseUrl: deerNormalizeBaseUrl(document.getElementById("apiBaseUrl").value || DEER_CLIPPER_DEFAULTS.apiBaseUrl),
+      webBaseUrl: deerNormalizeBaseUrl(document.getElementById("webBaseUrl").value || DEER_CLIPPER_DEFAULTS.webBaseUrl),
+    });
+    const response = await sendDiscoverServiceMessage();
+    const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+    document.getElementById("apiBaseUrl").value = settings.apiBaseUrl || "";
+    document.getElementById("webBaseUrl").value = settings.webBaseUrl || "";
+    document.getElementById("serviceStatus").textContent = response.message || formatServiceStatus(settings);
+  } catch (error) {
+    document.getElementById("serviceStatus").textContent = error instanceof Error ? error.message : "服务地址识别失败。";
+  } finally {
+    button.disabled = false;
+  }
+}
+
+async function syncTokenNow() {
+  const button = document.getElementById("syncToken");
+  button.disabled = true;
+  document.getElementById("tokenStatus").textContent = "正在同步 zncm token...";
+  try {
+    await chrome.storage.sync.set({
+      tokenSyncEnabled: document.getElementById("tokenSyncEnabled").checked,
+      apiBaseUrl: deerNormalizeBaseUrl(document.getElementById("apiBaseUrl").value || DEER_CLIPPER_DEFAULTS.apiBaseUrl),
+      webBaseUrl: deerNormalizeBaseUrl(document.getElementById("webBaseUrl").value || DEER_CLIPPER_DEFAULTS.webBaseUrl),
+    });
+    const response = await sendSyncTokenMessage();
+    const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+    document.getElementById("accessToken").value = settings.accessToken || "";
+    document.getElementById("apiBaseUrl").value = settings.apiBaseUrl || "";
+    document.getElementById("webBaseUrl").value = settings.webBaseUrl || "";
+    document.getElementById("serviceStatus").textContent = formatServiceStatus(settings);
+    document.getElementById("tokenStatus").textContent = response.message || formatTokenStatus(settings);
+  } catch (error) {
+    document.getElementById("tokenStatus").textContent = error instanceof Error ? error.message : "Token 同步失败。";
+  } finally {
+    button.disabled = false;
+  }
+}
+
+document.getElementById("save").addEventListener("click", saveSettings);
+document.getElementById("discoverService").addEventListener("click", discoverServiceNow);
+document.getElementById("syncToken").addEventListener("click", syncTokenNow);
+void loadSettings();

browser-extension/deer-web-clipper/popup.html

@@ -0,0 +1,31 @@
+<!doctype html>
+<html lang="zh-CN">
+  <head>
+    <meta charset="utf-8" />
+    <title>zncm Web Clipper</title>
+    <link rel="stylesheet" href="styles.css" />
+  </head>
+  <body>
+    <main class="popup">
+      <h1>zncm Web Clipper</h1>
+      <label>
+        首问
+        <textarea id="prompt" rows="4"></textarea>
+      </label>
+      <label class="checkbox">
+        <input id="pageAssistantEnabled" type="checkbox" />
+        启用页面问答框
+      </label>
+      <div class="actions">
+        <button id="send" type="button">发送当前页</button>
+        <button id="syncToken" type="button">同步 token</button>
+        <button id="pollNow" type="button">检查任务</button>
+        <button id="options" type="button" class="secondary">设置</button>
+      </div>
+      <p id="status" class="status"></p>
+    </main>
+    <script src="config.js"></script>
+    <script src="shared.js"></script>
+    <script src="popup.js"></script>
+  </body>
+</html>

browser-extension/deer-web-clipper/popup.js

@@ -0,0 +1,151 @@
+function setStatus(message) {
+  document.getElementById("status").textContent = message;
+}
+
+async function getActiveTab() {
+  const [tab] = await chrome.tabs.query({ active: true, currentWindow: true });
+  if (!tab?.id) {
+    throw new Error("No readable active tab found.");
+  }
+  return tab;
+}
+
+async function captureFromActiveTab(tabId) {
+  const [result] = await chrome.scripting.executeScript({
+    target: { tabId },
+    func: deerExtractCurrentPage,
+  });
+  if (!result?.result?.content) {
+    throw new Error("The current page has no readable text to send.");
+  }
+  return result.result;
+}
+
+async function submitToZncm(page, settings, prompt) {
+  const apiBaseUrl = deerNormalizeBaseUrl(settings.apiBaseUrl || DEER_CLIPPER_DEFAULTS.apiBaseUrl);
+  const response = await fetch(`${apiBaseUrl}/api/browser-context/capture`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...deerAuthHeaders(settings),
+    },
+    body: JSON.stringify({
+      title: page.title,
+      url: page.url,
+      content: page.content,
+      content_type: page.contentType,
+      prompt,
+    }),
+  });
+
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    const detail = typeof data.detail === "string" ? data.detail : JSON.stringify(data.detail || data);
+    throw new Error(detail || `HTTP ${response.status}`);
+  }
+  return data;
+}
+
+async function sendCurrentPage() {
+  const sendButton = document.getElementById("send");
+  sendButton.disabled = true;
+  setStatus("正在读取当前页面...");
+  try {
+    await syncToken({ silent: true });
+    const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+    const prompt = document.getElementById("prompt").value.trim() || settings.defaultPrompt || DEER_CLIPPER_DEFAULT_PROMPT;
+    const tab = await getActiveTab();
+    const page = await captureFromActiveTab(tab.id);
+    setStatus("正在发送到 zncm...");
+    const result = await submitToZncm(page, settings, prompt);
+    const webBaseUrl = deerNormalizeBaseUrl(settings.webBaseUrl || DEER_CLIPPER_DEFAULTS.webBaseUrl);
+    await chrome.tabs.create({ url: `${webBaseUrl}/${result.chat_url}`.replace(/\/#/g, "/#") });
+    setStatus("已发送，zncm 聊天页面已打开。");
+  } catch (error) {
+    setStatus(error instanceof Error ? error.message : "发送失败。");
+  } finally {
+    sendButton.disabled = false;
+  }
+}
+
+function sendSyncTokenMessage() {
+  return new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage({ type: "zncm-sync-token" }, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(response || { ok: false, message: "Token 同步没有返回结果。" });
+    });
+  });
+}
+
+function sendPollNowMessage() {
+  return new Promise((resolve, reject) => {
+    chrome.runtime.sendMessage({ type: "zncm-poll-now" }, (response) => {
+      const error = chrome.runtime.lastError;
+      if (error) {
+        reject(new Error(error.message));
+        return;
+      }
+      resolve(response || { ok: true, message: "Poll requested." });
+    });
+  });
+}
+
+async function syncToken(options = {}) {
+  const button = document.getElementById("syncToken");
+  button.disabled = true;
+  if (!options.silent) {
+    setStatus("正在同步 zncm token...");
+  }
+  try {
+    const response = await sendSyncTokenMessage();
+    if (!options.silent) {
+      setStatus(response.message || "Token sync finished.");
+    }
+    return response;
+  } catch (error) {
+    if (!options.silent) {
+      setStatus(error instanceof Error ? error.message : "Token 同步失败。");
+    }
+    return { ok: false, message: error instanceof Error ? error.message : "Token 同步失败。" };
+  } finally {
+    button.disabled = false;
+  }
+}
+
+async function pollNow() {
+  const button = document.getElementById("pollNow");
+  button.disabled = true;
+  setStatus("正在检查 zncm 浏览器任务...");
+  try {
+    await syncToken({ silent: true });
+    const response = await sendPollNowMessage();
+    setStatus(response.message || "任务检查完成。");
+  } catch (error) {
+    setStatus(error instanceof Error ? error.message : "任务检查失败。");
+  } finally {
+    button.disabled = false;
+  }
+}
+
+async function togglePageAssistant() {
+  const enabled = document.getElementById("pageAssistantEnabled").checked;
+  await chrome.storage.sync.set({ pageAssistantEnabled: enabled });
+  setStatus(enabled ? "页面问答框已开启。" : "页面问答框已关闭。");
+}
+
+async function init() {
+  const settings = await chrome.storage.sync.get(DEER_CLIPPER_DEFAULTS);
+  document.getElementById("prompt").value = settings.defaultPrompt || DEER_CLIPPER_DEFAULT_PROMPT;
+  document.getElementById("pageAssistantEnabled").checked = Boolean(settings.pageAssistantEnabled);
+  document.getElementById("send").addEventListener("click", sendCurrentPage);
+  document.getElementById("syncToken").addEventListener("click", () => syncToken());
+  document.getElementById("pollNow").addEventListener("click", pollNow);
+  document.getElementById("pageAssistantEnabled").addEventListener("change", togglePageAssistant);
+  document.getElementById("options").addEventListener("click", () => chrome.runtime.openOptionsPage());
+}
+
+void init();

browser-extension/deer-web-clipper/shared.js

@@ -0,0 +1,389 @@
+const DEER_CLIPPER_DEFAULT_PROMPT =
+  "\u8bf7\u57fa\u4e8e\u521a\u521a\u53d1\u9001\u7684\u7f51\u9875\u5185\u5bb9\uff0c\u5148\u7528\u4e2d\u6587\u603b\u7ed3\u8981\u70b9\uff0c\u5e76\u7b49\u5f85\u6211\u7ee7\u7eed\u63d0\u95ee\u3002";
+
+const ZNCM_EXTENSION_CONFIG = globalThis.ZNCM_WEB_CLIPPER_CONFIG || {};
+const ZNCM_DEFAULT_WEB_BASE_URL = String(ZNCM_EXTENSION_CONFIG.defaultWebBaseUrl || "").trim().replace(/\/+$/, "");
+const ZNCM_DEFAULT_API_BASE_URL = String(ZNCM_EXTENSION_CONFIG.defaultApiBaseUrl || "").trim().replace(/\/+$/, "");
+
+const DEER_CLIPPER_DEFAULTS = {
+  apiBaseUrl: ZNCM_DEFAULT_API_BASE_URL,
+  webBaseUrl: ZNCM_DEFAULT_WEB_BASE_URL,
+  autoDiscoverServiceUrl: true,
+  lastServiceSyncAt: "",
+  lastServiceSyncSource: "",
+  accessToken: "",
+  tokenSyncEnabled: true,
+  lastTokenSyncAt: "",
+  lastTokenSyncSource: "",
+  defaultPrompt: DEER_CLIPPER_DEFAULT_PROMPT,
+  pageAssistantEnabled: true,
+  taskPollingEnabled: true,
+  workerId: "",
+  taskPollIntervalSeconds: 5,
+  taskPageLoadTimeoutSeconds: 30,
+  closeTaskTabs: false,
+};
+
+function deerNormalizeBaseUrl(value) {
+  return String(value || "").trim().replace(/\/+$/, "");
+}
+
+function deerAuthHeaders(settings) {
+  const token = String(settings.accessToken || "").trim();
+  if (!token) {
+    return {};
+  }
+  return {
+    Authorization: /^bearer\s+/i.test(token) ? token : `Bearer ${token}`,
+  };
+}
+
+function deerMakeWorkerId() {
+  return `zncm-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+function deerExtractAuthTokenFromPage() {
+  const storageKeys = ["deerflow.auth"];
+  const tokenFieldNames = new Set(["access_token", "accessToken", "token", "id_token", "idToken"]);
+
+  function looksLikeToken(value) {
+    const text = String(value || "").trim();
+    return text.length > 20 && !/\s/.test(text);
+  }
+
+  function findToken(value, depth = 0) {
+    if (value == null || depth > 4) {
+      return "";
+    }
+    if (typeof value === "string") {
+      const text = value.trim();
+      if (!text) {
+        return "";
+      }
+      if ((text.startsWith("{") && text.endsWith("}")) || (text.startsWith("[") && text.endsWith("]"))) {
+        try {
+          return findToken(JSON.parse(text), depth + 1);
+        } catch {
+          return looksLikeToken(text) ? text : "";
+        }
+      }
+      return looksLikeToken(text) ? text : "";
+    }
+    if (typeof value !== "object") {
+      return "";
+    }
+    for (const [key, nested] of Object.entries(value)) {
+      if (tokenFieldNames.has(key) && looksLikeToken(nested)) {
+        return String(nested).trim();
+      }
+    }
+    for (const nested of Object.values(value)) {
+      const token = findToken(nested, depth + 1);
+      if (token) {
+        return token;
+      }
+    }
+    return "";
+  }
+
+  function scanStorage(storage, storageName) {
+    for (const key of storageKeys) {
+      const token = findToken(storage.getItem(key));
+      if (token) {
+        return { token, source: `${storageName}:${key}` };
+      }
+    }
+
+    for (let index = 0; index < storage.length; index += 1) {
+      const key = storage.key(index);
+      if (!key || !/(auth|token|session)/i.test(key)) {
+        continue;
+      }
+      const token = findToken(storage.getItem(key));
+      if (token) {
+        return { token, source: `${storageName}:${key}` };
+      }
+    }
+    return null;
+  }
+
+  try {
+    return scanStorage(window.localStorage, "localStorage") || scanStorage(window.sessionStorage, "sessionStorage");
+  } catch (error) {
+    return { token: "", source: "", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function deerExtractCurrentPage() {
+  const maxLocalChars = 220000;
+
+  function cleanText(value) {
+    return String(value || "")
+      .replace(/\s+\n/g, "\n")
+      .replace(/\n{3,}/g, "\n\n")
+      .trim();
+  }
+
+  function escapeCell(value) {
+    return cleanText(value).replace(/\|/g, "\\|").replace(/\n/g, " ");
+  }
+
+  function tableToMarkdown(table, index) {
+    const rows = Array.from(table.rows || []).map((row) =>
+      Array.from(row.cells || []).map((cell) => escapeCell(cell.innerText)),
+    );
+    if (rows.length === 0 || rows.every((row) => row.length === 0)) {
+      return "";
+    }
+    const width = Math.max(...rows.map((row) => row.length));
+    const normalized = rows.map((row) => {
+      const next = row.slice();
+      while (next.length < width) next.push("");
+      return next;
+    });
+    const header = normalized[0];
+    const divider = Array.from({ length: width }, () => "---");
+    const body = normalized.slice(1);
+    return [
+      `### Table ${index + 1}`,
+      "",
+      `| ${header.join(" | ")} |`,
+      `| ${divider.join(" | ")} |`,
+      ...body.map((row) => `| ${row.join(" | ")} |`),
+    ].join("\n");
+  }
+
+  const clone = document.body ? document.body.cloneNode(true) : null;
+  if (clone) {
+    clone.querySelectorAll("script, style, noscript, svg, canvas, iframe").forEach((node) => node.remove());
+  }
+
+  const title = document.title || "";
+  const url = location.href;
+  const description = document.querySelector('meta[name="description"]')?.getAttribute("content") || "";
+  const main = clone?.querySelector("article, main, [role='main']") || clone;
+  const text = cleanText(main?.innerText || document.body?.innerText || "");
+  const tables = Array.from(document.querySelectorAll("table"))
+    .map((table, index) => tableToMarkdown(table, index))
+    .filter(Boolean);
+
+  const parts = [];
+  if (description.trim()) {
+    parts.push(`## Meta Description\n\n${cleanText(description)}`);
+  }
+  if (text) {
+    parts.push(`## Page Text\n\n${text}`);
+  }
+  if (tables.length > 0) {
+    parts.push(`## Tables\n\n${tables.join("\n\n")}`);
+  }
+
+  let content = parts.join("\n\n");
+  if (content.length > maxLocalChars) {
+    content = `${content.slice(0, maxLocalChars)}\n\n[Truncated locally by zncm Web Clipper]`;
+  }
+
+  return { title, url, content, contentType: "markdown" };
+}
+
+// Injected into the page to build an indexed list of interactive elements plus
+// the visible page text. Each interactive element is tagged with
+// `data-deer-index` so a follow-up deerPerformAction call can find it by index.
+function deerObservePage(maxElements) {
+  const limit = Math.max(10, Number(maxElements || 150));
+  const DEER_ATTR = "data-deer-index";
+
+  document.querySelectorAll(`[${DEER_ATTR}]`).forEach((node) => node.removeAttribute(DEER_ATTR));
+
+  function isVisible(el) {
+    if (!(el instanceof Element)) return false;
+    const rect = el.getBoundingClientRect();
+    if (rect.width <= 1 && rect.height <= 1) return false;
+    const style = window.getComputedStyle(el);
+    if (style.visibility === "hidden" || style.display === "none" || style.opacity === "0") return false;
+    if (el.disabled) return false;
+    return true;
+  }
+
+  function labelFor(el) {
+    const aria = el.getAttribute("aria-label");
+    if (aria && aria.trim()) return aria.trim();
+    const placeholder = el.getAttribute("placeholder");
+    const title = el.getAttribute("title");
+    const name = el.getAttribute("name");
+    const text = (el.innerText || el.textContent || "").trim();
+    if (text) return text.replace(/\s+/g, " ");
+    if (placeholder && placeholder.trim()) return placeholder.trim();
+    if (title && title.trim()) return title.trim();
+    if (el.value && String(el.value).trim()) return String(el.value).trim();
+    if (name && name.trim()) return name.trim();
+    const alt = el.querySelector?.("img[alt]")?.getAttribute("alt");
+    if (alt && alt.trim()) return alt.trim();
+    return "";
+  }
+
+  const selector = [
+    "a[href]",
+    "button",
+    "input:not([type=hidden])",
+    "select",
+    "textarea",
+    "[role=button]",
+    "[role=link]",
+    "[role=tab]",
+    "[role=menuitem]",
+    "[role=checkbox]",
+    "[role=radio]",
+    "[role=switch]",
+    "[contenteditable=true]",
+    "[onclick]",
+  ].join(",");
+
+  const seen = new Set();
+  const elements = [];
+  let index = 0;
+  for (const el of document.querySelectorAll(selector)) {
+    if (index >= limit) break;
+    if (seen.has(el) || !isVisible(el)) continue;
+    seen.add(el);
+    el.setAttribute(DEER_ATTR, String(index));
+    const tag = el.tagName.toLowerCase();
+    let label = labelFor(el);
+    if (label.length > 200) label = label.slice(0, 200);
+    const entry = { index, tag, label };
+    const type = el.getAttribute("type") || el.getAttribute("role");
+    if (type) entry.type = type;
+    if (tag === "input" || tag === "textarea" || tag === "select") {
+      const value = String(el.value || "");
+      if (value) entry.value = value.slice(0, 80);
+    }
+    if (tag === "a") {
+      const href = el.getAttribute("href") || "";
+      if (href) entry.href = href.slice(0, 200);
+    }
+    elements.push(entry);
+    index += 1;
+  }
+
+  // Inline text extraction so this function stays self-contained when injected
+  // via chrome.scripting.executeScript (no dependency on other content-script fns).
+  let text = "";
+  try {
+    const clone = document.body ? document.body.cloneNode(true) : null;
+    if (clone) {
+      clone.querySelectorAll(`script, style, noscript, svg, canvas, iframe, [${DEER_ATTR}-skip]`).forEach((node) => node.remove());
+    }
+    const main = clone?.querySelector("article, main, [role='main']") || clone;
+    text = String(main?.innerText || document.body?.innerText || "")
+      .replace(/\s+\n/g, "\n")
+      .replace(/\n{3,}/g, "\n\n")
+      .trim();
+  } catch {
+    text = "";
+  }
+
+  return {
+    url: location.href,
+    title: document.title || "",
+    elements,
+    text,
+  };
+}
+
+// Injected into the page to perform a single action on the element previously
+// tagged by deerObservePage (by index). Returns {status, message}.
+async function deerPerformAction(action) {
+  const DEER_ATTR = "data-deer-index";
+  const type = String(action?.type || "").toLowerCase();
+
+  function findByIndex(idx) {
+    if (idx === undefined || idx === null || idx < 0) return null;
+    return document.querySelector(`[${DEER_ATTR}="${idx}"]`);
+  }
+
+  function fireInput(el, value) {
+    const proto = el instanceof HTMLTextAreaElement ? HTMLTextAreaElement.prototype : HTMLInputElement.prototype;
+    const setter = Object.getOwnPropertyDescriptor(proto, "value")?.set;
+    if (setter) {
+      setter.call(el, value);
+    } else {
+      el.value = value;
+    }
+    el.dispatchEvent(new Event("input", { bubbles: true }));
+    el.dispatchEvent(new Event("change", { bubbles: true }));
+  }
+
+  try {
+    if (type === "observe" || type === "extract") {
+      return { status: "ok", message: type === "extract" ? "Page text re-read." : "Observed page." };
+    }
+
+    if (type === "scroll") {
+      const el = findByIndex(action.index);
+      if (el) {
+        el.scrollIntoView({ block: "center", behavior: "instant" });
+        return { status: "ok", message: "Scrolled element into view." };
+      }
+      window.scrollBy(0, Math.round(window.innerHeight * 0.85));
+      return { status: "ok", message: "Scrolled down one viewport." };
+    }
+
+    if (type === "wait") {
+      const selector = String(action.wait_for || "").trim();
+      const timeoutMs = Math.max(500, Number(action.timeout_ms || 8000));
+      if (!selector) {
+        await new Promise((resolve) => setTimeout(resolve, Math.min(timeoutMs, 3000)));
+        return { status: "ok", message: "Waited." };
+      }
+      const start = Date.now();
+      while (Date.now() - start < timeoutMs) {
+        if (document.querySelector(selector)) {
+          return { status: "ok", message: `Element ${selector} appeared.` };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      return { status: "timeout", message: `Element ${selector} did not appear within ${timeoutMs}ms.` };
+    }
+
+    if (type === "click") {
+      const el = findByIndex(action.index);
+      if (!el) return { status: "error", message: `No element with index ${action.index}. Re-observe the page.` };
+      el.scrollIntoView({ block: "center", behavior: "instant" });
+      if (typeof el.focus === "function") el.focus();
+      el.click();
+      return { status: "ok", message: `Clicked element ${action.index}.` };
+    }
+
+    if (type === "type") {
+      const el = findByIndex(action.index);
+      if (!el) return { status: "error", message: `No element with index ${action.index}. Re-observe the page.` };
+      el.scrollIntoView({ block: "center", behavior: "instant" });
+      if (typeof el.focus === "function") el.focus();
+      const value = String(action.text ?? "");
+      if (el.isContentEditable) {
+        el.textContent = value;
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+      } else {
+        fireInput(el, value);
+      }
+      if (action.submit) {
+        const enterInit = { bubbles: true, cancelable: true, key: "Enter", code: "Enter", keyCode: 13, which: 13 };
+        el.dispatchEvent(new KeyboardEvent("keydown", enterInit));
+        el.dispatchEvent(new KeyboardEvent("keyup", enterInit));
+        const form = el.form || el.closest("form");
+        if (form && typeof form.requestSubmit === "function") {
+          try {
+            form.requestSubmit();
+          } catch {
+            form.submit?.();
+          }
+        }
+      }
+      return { status: "ok", message: `Typed into element ${action.index}${action.submit ? " and submitted" : ""}.` };
+    }
+
+    return { status: "error", message: `Unsupported action type: ${type}` };
+  } catch (error) {
+    return { status: "error", message: error instanceof Error ? error.message : String(error) };
+  }
+}

browser-extension/deer-web-clipper/styles.css

@@ -0,0 +1,96 @@
+* {
+  box-sizing: border-box;
+}
+
+body {
+  margin: 0;
+  color: #171717;
+  background: #fafafa;
+  font: 14px/1.5 system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+}
+
+h1 {
+  margin: 0 0 14px;
+  font-size: 16px;
+}
+
+.popup,
+.options {
+  display: grid;
+  gap: 12px;
+  padding: 14px;
+}
+
+.popup {
+  width: 340px;
+}
+
+.options {
+  max-width: 720px;
+}
+
+label {
+  display: grid;
+  gap: 6px;
+  font-weight: 600;
+}
+
+label.checkbox {
+  grid-template-columns: auto 1fr;
+  align-items: center;
+  font-weight: 500;
+}
+
+label.checkbox input {
+  width: auto;
+}
+
+.actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+input,
+textarea {
+  width: 100%;
+  border: 1px solid #d4d4d4;
+  border-radius: 6px;
+  padding: 8px;
+  background: #fff;
+  color: inherit;
+  font: inherit;
+  font-weight: 400;
+}
+
+textarea {
+  resize: vertical;
+}
+
+button {
+  border: 0;
+  border-radius: 6px;
+  padding: 9px 12px;
+  background: #111827;
+  color: #fff;
+  cursor: pointer;
+  font: inherit;
+  font-weight: 600;
+}
+
+button.secondary {
+  background: #e5e7eb;
+  color: #111827;
+}
+
+button:disabled {
+  cursor: not-allowed;
+  opacity: 0.6;
+}
+
+.status {
+  min-height: 20px;
+  margin: 0;
+  color: #525252;
+  white-space: pre-wrap;
+}

cankaoyangshi/.env.example

@@ -1,9 +0,0 @@
-# GEMINI_API_KEY: Required for Gemini AI API calls.
-# AI Studio automatically injects this at runtime from user secrets.
-# Users configure this via the Secrets panel in the AI Studio UI.
-GEMINI_API_KEY="MY_GEMINI_API_KEY"
-
-# APP_URL: The URL where this applet is hosted.
-# AI Studio automatically injects this at runtime with the Cloud Run service URL.
-# Used for self-referential links, OAuth callbacks, and API endpoints.
-APP_URL="MY_APP_URL"

cankaoyangshi/README.md

@@ -1,20 +0,0 @@
-<div align="center">
-<img width="1200" height="475" alt="GHBanner" src="https://ai.google.dev/static/site-assets/images/share-ais-513315318.png" />
-</div>
-
-# Run and deploy your AI Studio app
-
-This contains everything you need to run your app locally.
-
-View your app in AI Studio: https://ai.studio/apps/75261c35-a558-4ef8-9501-e8b7f9c98bfb
-
-## Run Locally
-
-**Prerequisites:**  Node.js
-
-
-1. Install dependencies:
-   `npm install`
-2. Set the `GEMINI_API_KEY` in [.env.local](.env.local) to your Gemini API key
-3. Run the app:
-   `npm run dev`

cankaoyangshi/index.html

@@ -1,13 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>My Google AI Studio App</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/main.tsx"></script>
-  </body>
-</html>
-

cankaoyangshi/metadata.json

@@ -1,6 +0,0 @@
-{
-  "name": "Gemini Style Assistant",
-  "description": "A clean, modern AI assistant interface inspired by Google Gemini with centered search, suggestion pills, and a minimalist sidebar.",
-  "requestFramePermissions": [],
-  "majorCapabilities": ["MAJOR_CAPABILITY_SERVER_SIDE_GEMINI_API"]
-}

cankaoyangshi/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "react-example",
-  "private": true,
-  "version": "0.0.0",
-  "type": "module",
-  "scripts": {
-    "dev": "vite --port=3000 --host=0.0.0.0",
-    "build": "vite build",
-    "preview": "vite preview",
-    "clean": "rm -rf dist server.js",
-    "lint": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@google/genai": "^1.29.0",
-    "@tailwindcss/vite": "^4.1.14",
-    "@vitejs/plugin-react": "^5.0.4",
-    "lucide-react": "^0.546.0",
-    "react": "^19.0.1",
-    "react-dom": "^19.0.1",
-    "vite": "^6.2.3",
-    "express": "^4.21.2",
-    "dotenv": "^17.2.3",
-    "motion": "^12.23.24"
-  },
-  "devDependencies": {
-    "@types/node": "^22.14.0",
-    "autoprefixer": "^10.4.21",
-    "esbuild": "^0.25.0",
-    "tailwindcss": "^4.1.14",
-    "tsx": "^4.21.0",
-    "typescript": "~5.8.2",
-    "vite": "^6.2.3",
-    "@types/express": "^4.17.21"
-  }
-}

cankaoyangshi/src/App.tsx

@@ -1,238 +0,0 @@
-/**
- * @license
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import { useState } from 'react';
-import { motion, AnimatePresence } from 'motion/react';
-import { 
-  MessageSquare, 
-  Bot, 
-  Wrench, 
-  Brain, 
-  ListChecks, 
-  Settings, 
-  Menu, 
-  Mic, 
-  Plus, 
-  Sparkles,
-  ArrowRight,
-  User,
-  History,
-  LayoutGrid,
-  Languages,
-  Code2,
-  Music,
-  Database,
-  Search
-} from 'lucide-react';
-
-export default function App() {
-  const [sidebarOpen, setSidebarOpen] = useState(true);
-
-  const navItems = [
-    { icon: MessageSquare, label: '对话', active: true },
-    { icon: Bot, label: '智能体' },
-    { icon: Wrench, label: '技能' },
-    { icon: Brain, label: '记忆' },
-    { icon: ListChecks, label: '任务管理' },
-  ];
-
-  const recentChats = [
-    'CM助手初次问候交谈',
-    'Untitled',
-    'Untitled',
-    'Untitled',
-    '帮我写一个500字的文案',
-    '帮我生成一个写论文的实例',
-  ];
-
-  const suggestions = [
-    { icon: Code2, label: 'Build an Android app', color: 'text-green-600', bg: 'bg-green-50' },
-    { icon: Languages, label: 'Convert text to speech', color: 'text-blue-600', bg: 'bg-blue-50' },
-    { icon: Music, label: 'Generate music', color: 'text-purple-600', bg: 'bg-purple-50' },
-    { icon: Database, label: 'Add database and auth', color: 'text-cyan-600', bg: 'bg-cyan-50' },
-  ];
-
-  return (
-    <div className="flex h-screen w-full bg-white font-sans text-gray-900 overflow-hidden">
-      {/* Sidebar */}
-      <motion.aside
-        initial={false}
-        animate={{ width: sidebarOpen ? 280 : 0, opacity: sidebarOpen ? 1 : 0 }}
-        className="relative bg-gray-50 border-r border-gray-100 flex flex-col h-full"
-      >
-        <div className="p-4 flex items-center justify-between">
-          <div className="flex items-center gap-2 px-2 py-1.5 bg-red-50 text-red-700 rounded-lg cursor-pointer">
-            <Plus size={18} />
-            <span className="font-medium text-sm">新对话</span>
-          </div>
-        </div>
-
-        <nav className="flex-1 overflow-y-auto px-2 space-y-1">
-          <div className="space-y-1 pb-4">
-            {navItems.map((item) => (
-              <div
-                key={item.label}
-                className={`flex items-center gap-3 px-3 py-2 rounded-xl cursor-pointer transition-colors ${
-                  item.active ? 'bg-white shadow-sm font-medium' : 'hover:bg-gray-100 text-gray-600'
-                }`}
-              >
-                <item.icon size={18} />
-                <span className="text-sm">{item.label}</span>
-              </div>
-            ))}
-          </div>
-
-          <div className="pt-4 border-t border-gray-200">
-            <h3 className="px-3 mb-2 text-xs font-semibold text-gray-400 uppercase tracking-wider">
-              最近对话
-            </h3>
-            {recentChats.map((chat, idx) => (
-              <div
-                key={idx}
-                className="px-3 py-1.5 text-sm text-gray-600 hover:bg-gray-100 rounded-lg cursor-pointer truncate"
-              >
-                {chat}
-              </div>
-            ))}
-          </div>
-        </nav>
-
-        <div className="p-4 border-t border-gray-200">
-          <div className="flex items-center gap-3 px-3 py-2 text-gray-600 hover:bg-gray-100 rounded-xl cursor-pointer">
-            <Settings size={18} />
-            <span className="text-sm">设置和更多</span>
-          </div>
-        </div>
-      </motion.aside>
-
-      {/* Main Content */}
-      <main className="flex-1 flex flex-col relative h-full overflow-y-auto">
-        {/* Top bar */}
-        <header className="absolute top-0 w-full p-4 flex items-center justify-between z-10">
-          <button
-            onClick={() => setSidebarOpen(!sidebarOpen)}
-            className="p-2 hover:bg-gray-100 rounded-lg text-gray-500 transition-colors"
-          >
-            <Menu size={20} />
-          </button>
-          
-          <div className="flex items-center gap-2">
-            <button className="p-2 hover:bg-gray-100 rounded-lg text-gray-500 transition-colors">
-              <Settings size={20} />
-            </button>
-            <div className="w-8 h-8 rounded-full bg-gradient-to-tr from-blue-400 to-purple-400 flex items-center justify-center text-white shadow-sm ring-2 ring-white cursor-pointer overflow-hidden">
-              <User size={16} />
-            </div>
-          </div>
-        </header>
-
-        {/* Center Canvas */}
-        <div className="flex-1 flex flex-col items-center justify-center px-4 max-w-4xl mx-auto w-full pt-16">
-          <motion.div
-            initial={{ opacity: 0, y: 20 }}
-            animate={{ opacity: 1, y: 0 }}
-            className="text-center mb-12 relative"
-          >
-            <div className="absolute -top-16 left-1/2 -translate-x-1/2 opacity-10 blur-2xl pointer-events-none">
-              <Sparkles size={120} className="text-blue-500 animate-pulse" />
-            </div>
-            <h1 className="text-5xl font-display font-medium tracking-tight bg-clip-text text-transparent bg-gradient-to-r from-gray-900 to-gray-500 mb-4 px-4">
-              Build your ideas with Gemini
-            </h1>
-            <Sparkles className="absolute -right-8 top-0 text-blue-200 opacity-50" size={48} />
-          </motion.div>
-
-          {/* Search/Input Area */}
-          <motion.div
-             initial={{ opacity: 0, scale: 0.95 }}
-             animate={{ opacity: 1, scale: 1 }}
-             transition={{ delay: 0.1 }}
-             className="w-full max-w-2xl relative group"
-          >
-            <div className="gemini-gradient-border gemini-shadow rounded-3xl bg-white p-2">
-              <div className="flex flex-col p-4 space-y-4">
-                <textarea
-                  placeholder="Describe an app and let Gemini do the rest"
-                  className="w-full bg-transparent resize-none focus:outline-none text-lg text-gray-700 min-h-[80px]"
-                />
-                
-                <div className="flex items-center justify-between pt-2">
-                  <div className="flex items-center gap-2">
-                    <button className="p-2 hover:bg-gray-100 rounded-full text-gray-400 transition-colors">
-                      <Mic size={20} />
-                    </button>
-                    <button className="p-2 hover:bg-gray-100 rounded-full text-gray-400 transition-colors">
-                      <Plus size={20} />
-                    </button>
-                  </div>
-                  
-                  <button className="flex items-center gap-2 px-5 py-2.5 bg-gray-50 hover:bg-gray-100 text-gray-700 rounded-full border border-gray-200 transition-all font-medium text-sm group/btn shadow-sm">
-                    <Sparkles size={16} className="text-blue-500" />
-                    I'm feeling lucky
-                    <ArrowRight size={14} className="opacity-0 -translate-x-2 group-hover/btn:opacity-100 group-hover/btn:translate-x-0 transition-all" />
-                  </button>
-                </div>
-              </div>
-            </div>
-          </motion.div>
-
-          {/* Suggestion Chips */}
-          <div className="mt-8 flex flex-wrap justify-center gap-3">
-            {suggestions.map((suggestion, idx) => (
-              <motion.button
-                key={suggestion.label}
-                initial={{ opacity: 0, y: 10 }}
-                animate={{ opacity: 1, y: 0 }}
-                transition={{ delay: 0.2 + idx * 0.05 }}
-                whileHover={{ scale: 1.02 }}
-                whileTap={{ scale: 0.98 }}
-                className={`flex items-center gap-2 px-4 py-2.5 rounded-2xl border border-gray-100 bg-white hover:bg-gray-50 shadow-sm transition-all text-sm font-medium group hover:border-gray-200 text-gray-700`}
-              >
-                <suggestion.icon className={`w-4 h-4 ${suggestion.color}`} />
-                {suggestion.label}
-              </motion.button>
-            ))}
-            <motion.button
-               initial={{ opacity: 0, y: 10 }}
-               animate={{ opacity: 1, y: 0 }}
-               transition={{ delay: 0.4 }}
-               className="flex items-center justify-center p-2 rounded-full border border-gray-100 bg-white hover:bg-gray-50 text-gray-400 shadow-sm transition-all"
-            >
-              <ArrowRight size={16} />
-            </motion.button>
-          </div>
-        </div>
-
-        {/* Footer info/links */}
-        <footer className="w-full max-w-4xl mx-auto px-4 py-12 mt-auto">
-          <div className="rounded-3xl border border-gray-100 bg-gray-50/50 p-8 flex items-center justify-between group hover:bg-gray-50 transition-colors">
-            <div>
-              <h2 className="text-2xl font-display font-medium text-gray-800 mb-1">
-                Discover and remix app ideas
-              </h2>
-              <p className="text-gray-500 text-sm italic">
-                (Gallery view pending implementation)
-              </p>
-            </div>
-            <button className="flex items-center gap-2 px-6 py-2.5 bg-white border border-gray-200 rounded-xl hover:shadow-md transition-all font-medium text-gray-700">
-              Browse the app gallery
-              <ArrowRight size={18} />
-            </button>
-          </div>
-        </footer>
-        
-        {/* Floating Right Bar (from target image) */}
-        <div className="absolute right-6 top-1/2 -translate-y-1/2 flex flex-col gap-4">
-          <button className="p-2.5 bg-white shadow-lg border border-gray-100 rounded-xl hover:scale-110 transition-all text-gray-400">
-            <LayoutGrid size={22} />
-          </button>
-          <button className="p-2.5 bg-white shadow-lg border border-gray-100 rounded-xl hover:scale-110 transition-all text-gray-400">
-            <Languages size={22} />
-          </button>
-        </div>
-      </main>
-    </div>
-  );
-}

cankaoyangshi/src/index.css

@@ -1,71 +0,0 @@
-@import "tailwindcss";
-
-@theme {
-  --font-sans: "Inter", ui-sans-serif, system-ui, sans-serif;
-  --font-display: "Outfit", "Inter", sans-serif;
-}
-
-@layer base {
-  body {
-    @apply bg-white text-gray-900 antialiased;
-  }
-}
-
-@layer utilities {
-  .gemini-shadow {
-    box-shadow: 0 0 20px rgba(66, 133, 244, 0.08),
-                0 0 40px rgba(219, 68, 55, 0.04),
-                0 0 60px rgba(244, 180, 0, 0.04),
-                0 0 80px rgba(15, 157, 88, 0.04);
-  }
-  
-  .gemini-gradient-border {
-    position: relative;
-    background: white;
-    border-radius: 1.5rem; /* rounded-3xl */
-    z-index: 0;
-    overflow: hidden;
-  }
-  
-  .gemini-gradient-border::before {
-    content: '';
-    position: absolute;
-    width: 150%;
-    height: 150%;
-    top: -25%;
-    left: -25%;
-    background: conic-gradient(
-      from 0deg,
-      transparent 0deg,
-      transparent 90deg,
-      #4285F4 120deg,
-      #DB4437 150deg,
-      #F4B400 180deg,
-      #0F9D58 210deg,
-      transparent 240deg
-    );
-    z-index: -2;
-    animation: rotate 3s linear infinite;
-    filter: blur(15px);
-  }
-
-  .gemini-gradient-border::after {
-    content: '';
-    position: absolute;
-    inset: 1.5px; /* The "thickness" of the glow border */
-    background: white;
-    border-radius: calc(1.5rem - 1px);
-    z-index: -1;
-  }
-
-  @keyframes rotate {
-    from {
-      transform: rotate(0deg);
-    }
-    to {
-      transform: rotate(360deg);
-    }
-  }
-}
-
-@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&family=Outfit:wght@400;500;600&display=swap');

cankaoyangshi/src/main.tsx

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

cankaoyangshi/tsconfig.json

@@ -1,26 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "experimentalDecorators": true,
-    "useDefineForClassFields": false,
-    "module": "ESNext",
-    "lib": [
-      "ES2022",
-      "DOM",
-      "DOM.Iterable"
-    ],
-    "skipLibCheck": true,
-    "moduleResolution": "bundler",
-    "isolatedModules": true,
-    "moduleDetection": "force",
-    "allowJs": true,
-    "jsx": "react-jsx",
-    "paths": {
-      "@/*": [
-        "./*"
-      ]
-    },
-    "allowImportingTsExtensions": true,
-    "noEmit": true
-  }
-}

cankaoyangshi/vite.config.ts

@@ -1,22 +0,0 @@
-import tailwindcss from '@tailwindcss/vite';
-import react from '@vitejs/plugin-react';
-import path from 'path';
-import {defineConfig} from 'vite';
-
-export default defineConfig(() => {
-  return {
-    plugins: [react(), tailwindcss()],
-    resolve: {
-      alias: {
-        '@': path.resolve(__dirname, '.'),
-      },
-    },
-    server: {
-      // HMR is disabled in AI Studio via DISABLE_HMR env var.
-      // Do not modify—file watching is disabled to prevent flickering during agent edits.
-      hmr: process.env.DISABLE_HMR !== 'true',
-      // Disable file watching when DISABLE_HMR is true to save CPU during agent edits.
-      watch: process.env.DISABLE_HMR === 'true' ? null : {},
-    },
-  };
-});

docs/superpowers/plans/2026-06-01-iframe-chat-page.md

@@ -0,0 +1,139 @@
+# Iframe Chat Page Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Add a standalone `/page/workspace/chats_iframe/*` chat page that reuses the existing thread system and history, while showing only `你好` and no input box before the first user message.
+
+**Architecture:** Keep the existing workspace shell and chat runtime intact, then add a new route pair and a copied page component dedicated to the iframe path. The new page keeps the original chat behavior once a thread already has messages, but it owns its empty-state rendering and URL transition to `/page/workspace/chats_iframe/:thread_id`.
+
+**Tech Stack:** React, TypeScript, React Router, Next navigation shim, existing LangGraph thread hooks
+
+---
+
+### Task 1: Add the iframe chat routes
+
+**Files:**
+- Modify: `frontend-web/src/pages/WorkspaceRoutes.tsx`
+
+- [ ] **Step 1: Add `chats_iframe/new` and `chats_iframe/:thread_id` routes that render the new page inside the existing workspace layout and chat runtime**
+
+```tsx
+      <Route
+        path="chats_iframe/new"
+        element={
+          <WorkspaceLayout {...layoutProps}>
+            <ChatRuntime>
+              <IframeChatPage />
+            </ChatRuntime>
+          </WorkspaceLayout>
+        }
+      />
+      <Route
+        path="chats_iframe/:thread_id"
+        element={
+          <WorkspaceLayout {...layoutProps}>
+            <ChatRuntime>
+              <IframeChatPage />
+            </ChatRuntime>
+          </WorkspaceLayout>
+        }
+      />
+```
+
+- [ ] **Step 2: Ensure the new route imports compile cleanly**
+
+Run: `rg -n "IframeChatPage|chats_iframe" frontend-web/src/pages/WorkspaceRoutes.tsx`
+Expected: `WorkspaceRoutes.tsx` contains one import for `IframeChatPage` and both `chats_iframe` route entries.
+
+### Task 2: Add a standalone iframe chat page
+
+**Files:**
+- Create: `frontend-web/src/pages/IframeChatPage.tsx`
+- Reference: `frontend-web/src/pages/ChatPage.tsx`
+
+- [ ] **Step 1: Copy the current `ChatPage` implementation into `IframeChatPage` and preserve the existing chat runtime integration**
+
+```tsx
+export default function IframeChatPage() {
+  const routeBase = useRouteBase();
+  const router = useRouter();
+  const [showFollowups, setShowFollowups] = useState(false);
+  const [hasStartedConversation, setHasStartedConversation] = useState(false);
+  const { threadId, setThreadId, isNewThread, setIsNewThread, isMock } =
+    useThreadChat();
+  // keep the rest of the existing chat hooks and handlers aligned with ChatPage
+}
+```
+
+- [ ] **Step 2: Change the thread creation URL replacement to stay on the iframe route family**
+
+```tsx
+    onStart: (createdThreadId) => {
+      setThreadId(createdThreadId);
+      setIsNewThread(false);
+      history.replaceState(
+        null,
+        "",
+        `${window.location.pathname}${window.location.search}#${routeBase}/chats_iframe/${createdThreadId}`,
+      );
+    },
+```
+
+- [ ] **Step 3: Replace the default landing state with a simple `你好` view and do not render the input box while the iframe page is still a brand-new untouched chat**
+
+```tsx
+                {isLandingState && mounted ? (
+                  <div className="flex min-h-[240px] items-center justify-center">
+                    <div className="text-2xl font-medium">你好</div>
+                  </div>
+                ) : null}
+                {!isLandingState &&
+                  (mounted ? (
+                    <div className="w-full -translate-y-4">
+                      <InputBox
+                        className="w-full"
+                        isNewThread={false}
+                        threadId={threadId}
+                        autoFocus={false}
+                        status={thread.error ? "error" : thread.isLoading ? "streaming" : "ready"}
+                        context={settings.context}
+                        disabled={env.NEXT_PUBLIC_STATIC_WEBSITE_ONLY === "true" || isUploading}
+                        onContextChange={(context) => setSettings("context", context)}
+                        promptPrefix={promptPrefixProp}
+                        onFollowupsVisibilityChange={setShowFollowups}
+                        onSubmit={handleSubmit}
+                        onStop={handleStop}
+                      />
+                    </div>
+                  ) : (
+                    <div aria-hidden="true" className="bg-background/5 h-32 w-full -translate-y-4 rounded-3xl border" />
+                  ))}
+```
+
+- [ ] **Step 4: Keep message rendering, thread title, export, token usage, todos, artifact triggers, and all post-first-message behavior identical to the original page**
+
+Run: `rg -n "MessageList|ThreadTitle|ArtifactTrigger|TokenUsageIndicator|TodoList" frontend-web/src/pages/IframeChatPage.tsx`
+Expected: The new page still renders the same core chat primitives used by `ChatPage`.
+
+### Task 3: Verify the new page compiles
+
+**Files:**
+- Test: `frontend-web/src/pages/IframeChatPage.tsx`
+- Test: `frontend-web/src/pages/WorkspaceRoutes.tsx`
+
+- [ ] **Step 1: Run the frontend build**
+
+Run: `cmd /c npm run build`
+Expected: Build succeeds without TypeScript or bundling errors related to `IframeChatPage` or `chats_iframe`.
+
+- [ ] **Step 2: Spot-check the changed routes in the built source**
+
+Run: `rg -n "chats_iframe" frontend-web/src/pages`
+Expected: Matches appear in `WorkspaceRoutes.tsx` and `IframeChatPage.tsx`.
+
+- [ ] **Step 3: Commit after verification**
+
+```bash
+git add docs/superpowers/plans/2026-06-01-iframe-chat-page.md frontend-web/src/pages/WorkspaceRoutes.tsx frontend-web/src/pages/IframeChatPage.tsx
+git commit -m "feat: add iframe chat page routes"
+```

frontend-web/.env.development

@@ -0,0 +1,56 @@
+# 本地开发（pnpm dev）— 与原先 .env 保持一致
+# 个人覆盖请新建 .env.development.local（已 gitignore，优先级更高）
+
+# 任务看板数据源：true=真实接口（默认）；改成 false 可让任务分析/三情分析两页走本地假数据。
+VITE_USE_REAL_DATA=true
+
+# 任务详情（登录深链 cop-task-detail）数据源：默认真实接口；改成 true 走本地假数据（consumer 外网不可达时调试用）。
+VITE_MOCK_COP_TASK_DETAIL=true
+
+# 研判情报报告（大屏绘制智能体深链 selectSqReport）数据源：true 走本地样例假数据（真实接口未就绪时调试用）；联调通过后置 false。
+VITE_MOCK_SQ_REPORT=true
+
+# 深链任务详情（cop-task-detail：任务名称/描述）数据源：true 走本地假数据（真实接口未就绪时调试用）；联调通过后置 false。
+VITE_MOCK_COP_TASK_DETAIL=true
+
+# Gateway / DeerFlow API
+VITE_BACKEND_BASE_URL=http://127.0.0.1:8001
+VITE_LANGGRAPH_BASE_URL=http://127.0.0.1:8001/api
+
+# 轻应用「新建笔记」系列接口
+VITE_NOTE_API_BASE_URL=http://47.88.25.99:8000
+# CMZS后端接口
+VITE_API_BASE_URL=https://ch1.b.uat.4.cn/zncm
+# 佳来模型对话接口
+VITE_AIPI_CHAT_URL=https://ch1.b.uat.4.cn/gpt
+# 多轮检索接口
+VITE_AIPI_GENERATE_CHAT_URL=https://ch1.b.uat.4.cn/jialai_b1_chat
+VITE_AIPI_TASK_CHAT_URL=https://ch1.b.uat.4.cn/qq_b1_chat
+VITE_AIPI_KNOWLEDGE_URL=https://chlib.b.uat.4.cn/knowlibrary
+VITE_AIPI_B1COH_URL=https://ch1.b.uat.4.cn/web
+VITE_AIPI_B2ACTOR_URL=https://ty.b.uat.4.cn
+VITE_AIPI_B2ACTOR_XWT_PATH=/fromB/toXWT?isFrame=1
+VITE_AIPI_KNOWLEDGE_IFRAME_API_URL=https://ch1.b.uat.4.cn/knowes/api/iframeKnowledgeUrl
+VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
+VITE_AIPI_B2ACTOR_XWT_PATH=/fromB/toXWT?isFrame=1
+VITE_AIPI_KNOWLEDGE_IFRAME_API_URL=https://ch1.b.uat.4.cn/knowes/api/iframeKnowledgeUrl
+VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
+VITE_AIPI_MOPECHAT_URL=https://ch1.b.uat.4.cn/likun_b1_mope
+VITE_AIPI_BACKENP_URL=http://47.88.25.99:8000
+# 工作室/空间后端接口（侧边栏“工作室”列表、空间详情等都走这里，不是 VITE_NOTE_API_BASE_URL）
+# 工作室/空间前端地址（用于 auth/callback 等跳转）
+# VITE_AIPI_FRONTEND_URL=https://knowledgetoolserver.b.uat.4.cn
+VITE_AIPI_FRONTEND_URL=http://localhost:3000
+VITE_AIPI_CONSUMER_URL=https://ch1.b.uat.4.cn/consumer
+# A 系统跳转地址（人物/组织/事件等列表项打开链接）
+VITE_AIPI_PRESENT_URL=https://present.a.uat.4.cn/present/domain
+# B 系统知识库 iframe 根地址
+VITE_AIPI_KNOWES_URL=https://ch1.b.uat.4.cn/knowes
+
+# MaxKey 鉴权（getTokenByOnlineTicket）
+VITE_AUTH_BASE_URL=https://auth.y.sit.4.cn
+VITE_AIPI_PGLINKTO_URL=https://pg.b.uat.4.cn
+VITE_AIPI_XKLINKTO_URL=https://kz.b.uat.4.cn
+# 可选：Canvas 独立 LangGraph 地址（不设则回退到 VITE_LANGGRAPH_BASE_URL）
+# VITE_CANVAS_LANGGRAPH_BASE_URL=
+

frontend-web/.env.development.local.example

@@ -0,0 +1,31 @@
+# 复制为 .env.development.local，仅本机生效，不提交 Git
+# 直连本机 Gateway（需后端 CORS_ORIGINS 包含 http://127.0.0.1:5173 等）
+
+VITE_BACKEND_BASE_URL=http://127.0.0.1:8001
+VITE_LANGGRAPH_BASE_URL=http://127.0.0.1:8001/api
+# 佳来模型对话接口
+VITE_AIPI_CHAT_URL=https://ch1.b.uat.4.cn/gpt
+# 多轮检索接口
+VITE_AIPI_GENERATE_CHAT_URL=https://ch1.b.uat.4.cn/jialai_b1_chat
+VITE_AIPI_TASK_CHAT_URL=https://ch1.b.uat.4.cn/qq_b1_chat
+VITE_AIPI_KNOWLEDGE_URL=https://chlib.b.uat.4.cn/knowlibrary
+VITE_AIPI_B1COH_URL=https://ch1.b.uat.4.cn/web
+VITE_AIPI_B2ACTOR_URL=https://ty.b.uat.4.cn
+VITE_AIPI_B2ACTOR_XWT_PATH=/fromB/toXWT?isFrame=1
+VITE_AIPI_KNOWLEDGE_IFRAME_API_URL=https://ch1.b.uat.4.cn/knowes/api/iframeKnowledgeUrl
+VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
+VITE_AIPI_MOPECHAT_URL=https://ch1.b.uat.4.cn/likun_b1_mope
+# 工作室/空间后端接口（侧边栏“工作室”列表、空间详情等都走这里，不是 VITE_NOTE_API_BASE_URL）
+VITE_AIPI_BACKENP_URL=https://knowledgetoolserver.b.uat.4.cn
+# 工作室/空间前端地址（用于 auth/callback 等跳转）
+VITE_AIPI_FRONTEND_URL=https://knowledgetoolserver.b.uat.4.cn
+VITE_AIPI_CONSUMER_URL=https://ch1.b.uat.4.cn/consumer
+# A 系统跳转地址（人物/组织/事件等列表项打开链接）
+VITE_AIPI_PRESENT_URL=http://present.a.uat.4.cn/present/domain
+# B 系统知识库 iframe 根地址
+VITE_AIPI_KNOWES_URL=http://ch1.b.uat.4.cn/knowes
+VITE_AUTH_BASE_URL=https://auth.y.sit.4.cn
+VITE_AIPI_PGLINKTO_URL=https://pg.b.uat.4.cn
+VITE_AIPI_XKLINKTO_URL=https://kz.b.uat.4.cn
+
+# VITE_NOTE_API_BASE_URL=http://127.0.0.1:8000

frontend-web/.env.example

@@ -1,6 +1,59 @@
-# 复制为 .env 后按需修改（Vite 仅暴露以 VITE_ 开头的变量）
-# 直连本机 Gateway 时使用；若浏览器报 CORS，请在网关环境设置 CORS_ORIGINS，包含前端源站，例如：
-#   CORS_ORIGINS=http://127.0.0.1:5173,http://localhost:5173
+# 环境变量说明（Vite 仅暴露以 VITE_ 开头的变量）
+#
+# ┌─────────────────┬──────────────────────────────────────────────────┐
+# │ 命令            │ 生效文件                                          │
+# ├─────────────────┼──────────────────────────────────────────────────┤
+# │ pnpm dev        │ .env.development + .env.development.local        │
+# │ pnpm build      │ .env.production + .env.production.local          │
+# │ pnpm build:network │ .env.network + .env.network.local（内网地址） │
+# │ scripts/start-* │ 脚本注入的环境变量会覆盖上述文件（见下方说明）      │
+# └─────────────────┴──────────────────────────────────────────────────┘
+#
+# 推荐：
+# - 日常本地开发：改 .env.development（已提交，团队默认 UAT 地址）
+# - 本机连 127.0.0.1:8001：复制 .env.development.local.example → .env.development.local
+# - 内网打包部署：改 .env.network 后执行 pnpm build:network（或改 .env.production 后 pnpm build）
+#
+# 若浏览器直连后端报 CORS，请在 Gateway 配置 GATEWAY_CORS_ORIGINS，包含前端源站；无界嵌入时还要加宿主源站，例如：
+#   GATEWAY_CORS_ORIGINS=http://127.0.0.1:5174,http://localhost:5174,http://127.0.0.1:5183,http://localhost:5183
 
-VITE_BACKEND_BASE_URL=http://127.0.0.1:8001
-VITE_LANGGRAPH_BASE_URL=http://127.0.0.1:8001/api
+# --- 开发环境（见 .env.development）---
+# VITE_BACKEND_BASE_URL=https://ch1.b.uat.4.cn/deerflow
+# VITE_LANGGRAPH_BASE_URL=https://ch1.b.uat.4.cn/deerflow/api
+# VITE_NOTE_API_BASE_URL=http://47.88.25.99:8000
+# VITE_AIPI_BACKENP_URL=https://knowledgetoolserver.b.uat.4.cn
+# VITE_AIPI_FRONTEND_URL=https://knowledgetoolserver.b.uat.4.cn
+
+# --- 生产打包（见 .env.production）---
+# 部署前修改 .env.production 中的地址，再执行 pnpm build
+
+# --- 任务看板（任务分析 / 三情分析）数据源开关 ---
+# true=走真实接口；false 或未设=这两页使用本地假数据（演示用，无需后端）。
+# .env.development / .env.production / .env.network / .env.sit 均默认 true（真实数据），
+# 仅本机 .env 默认 false（假数据）。改后需重启 dev / 重新打包生效。
+# VITE_USE_REAL_DATA=true
+
+# --- 任务详情（登录深链 cop-task-detail）数据源开关 ---
+# 默认真实接口（未设/false）；改成 true 时该接口走本地假数据（consumer 外网不可达时调试用）。
+# 与 VITE_USE_REAL_DATA 独立。改后需重启 dev / 重新打包生效。
+# VITE_MOCK_COP_TASK_DETAIL=false
+# VITE_POSITION_ROUNDTABLE_DEMO_MODE=false
+# true=免登录直达岗位分析，完全使用前端 JSON，不请求任何后台接口。
+# 仅限离线演示环境；生产环境请保持 false。
+# VITE_POSITION_ROUNDTABLE_STANDALONE_MODE=false
+
+# MaxKey 鉴权根地址（无界 onlineTicket 换 token）
+# VITE_AUTH_BASE_URL=https://auth.y.sit.4.cn
+# VITE_AIPI_CONSUMER_URL=https://ch1.b.uat.4.cn/consumer
+
+# VITE_AIPI_B2ACTOR_URL=https://ty.b.uat.4.cn
+# VITE_AIPI_B2ACTOR_XWT_PATH=/fromB/toXWT?isFrame=1
+# VITE_AIPI_KNOWLEDGE_IFRAME_API_URL=https://ch1.b.uat.4.cn/knowes/api/iframeKnowledgeUrl
+# VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
+
+# 可选
+# VITE_CANVAS_LANGGRAPH_BASE_URL=
+# VITE_STATIC_WEBSITE_ONLY=
+# 部署级紧凑导航：true 时固定收起工作台左侧栏，并隐藏换肤与全量/简洁模式切换。
+# VITE_FORCE_COLLAPSED_SIDEBAR=false
+# VITE_GITHUB_OAUTH_TOKEN=

frontend-web/.env.network

@@ -0,0 +1,57 @@
+# 本地开发（pnpm dev）— 与原先 .env 保持一致
+# 个人覆盖请新建 .env.development.local（已 gitignore，优先级更高）
+
+# 任务看板数据源：true=真实接口（默认）；改成 false 可让任务分析/三情分析两页走本地假数据。
+VITE_USE_REAL_DATA=true
+
+# 任务详情（登录深链 cop-task-detail）数据源：默认真实接口；改成 true 走本地假数据（调试用）。
+VITE_MOCK_COP_TASK_DETAIL=false
+
+# 研判情报报告（大屏绘制智能体深链 selectSqReport）数据源：默认真实接口；真实接口未就绪可改 true 走本地样例假数据。
+VITE_MOCK_SQ_REPORT=false
+
+# 深链任务详情（cop-task-detail）数据源：默认真实接口；真实接口未就绪可改 true 走本地假数据。
+VITE_MOCK_COP_TASK_DETAIL=false
+
+# Gateway / DeerFlow API
+VITE_BACKEND_BASE_URL=http://10.19.200.5:2026
+VITE_LANGGRAPH_BASE_URL=http://10.19.200.5:2026/api
+
+# 轻应用「新建笔记」系列接口
+VITE_NOTE_API_BASE_URL=http://47.88.25.99:8000
+# CMZS后端接口
+VITE_API_BASE_URL=https://ch1.b.uat.4.cn/zncm
+# 佳来模型对话接口
+VITE_AIPI_CHAT_URL=https://ch1.b.uat.4.cn/gpt
+# 多轮检索接口
+VITE_AIPI_GENERATE_CHAT_URL=https://ch1.b.uat.4.cn/jialai_b1_chat
+VITE_AIPI_TASK_CHAT_URL=https://ch1.b.uat.4.cn/qq_b1_chat
+VITE_AIPI_KNOWLEDGE_URL=https://chlib.b.uat.4.cn/knowlibrary
+VITE_AIPI_B1COH_URL=https://ch1.b.uat.4.cn/web
+VITE_AIPI_B2ACTOR_URL=https://ty.b.uat.4.cn
+VITE_AIPI_B2ACTOR_XWT_PATH=/fromB/toXWT?isFrame=1
+VITE_AIPI_KNOWLEDGE_IFRAME_API_URL=https://ch1.b.uat.4.cn/knowes/api/iframeKnowledgeUrl
+VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
+VITE_AIPI_B2ACTOR_XWT_PATH=/fromB/toXWT?isFrame=1
+VITE_AIPI_KNOWLEDGE_IFRAME_API_URL=https://ch1.b.uat.4.cn/knowes/api/iframeKnowledgeUrl
+VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
+VITE_AIPI_MOPECHAT_URL=https://ch1.b.uat.4.cn/likun_b1_mope
+VITE_AIPI_BACKENP_URL=http://47.88.25.99:8000
+# 工作室/空间后端接口（侧边栏“工作室”列表、空间详情等都走这里，不是 VITE_NOTE_API_BASE_URL）
+# 工作室/空间前端地址（用于 auth/callback 等跳转）
+# VITE_AIPI_FRONTEND_URL=https://knowledgetoolserver.b.uat.4.cn
+VITE_NOTEBOOK_API_BASE_URL=http://47.88.25.99:8000
+VITE_AIPI_FRONTEND_URL=http://47.88.25.99:3000
+VITE_AIPI_CONSUMER_URL=http://10.19.200.5:8002/consumer
+# A 系统跳转地址（人物/组织/事件等列表项打开链接）
+VITE_AIPI_PRESENT_URL=http://present.a.uat.4.cn/present/domain
+# B 系统知识库 iframe 根地址
+VITE_AIPI_KNOWES_URL=http://ch1.b.uat.4.cn/knowes
+
+# MaxKey 鉴权（getTokenByOnlineTicket）
+VITE_AUTH_BASE_URL=https://auth.y.sit.4.cn
+VITE_AIPI_PGLINKTO_URL=https://pg.b.uat.4.cn
+VITE_AIPI_XKLINKTO_URL=https://kz.b.uat.4.cn
+# 可选：Canvas 独立 LangGraph 地址（不设则回退到 VITE_LANGGRAPH_BASE_URL）
+# VITE_CANVAS_LANGGRAPH_BASE_URL=
+

frontend-web/.env.production

@@ -0,0 +1,50 @@
+# 生产打包（pnpm build）— 部署前请改成实际内网/生产地址
+# 打包后变量会写入 dist，运行时不可再改
+
+# 任务看板数据源：true=真实接口（默认）；改成 false 可让任务分析/三情分析两页走本地假数据。
+VITE_USE_REAL_DATA=true
+
+# 任务详情（登录深链 cop-task-detail）数据源：默认真实接口；改成 true 走本地假数据（调试用）。
+VITE_MOCK_COP_TASK_DETAIL=false
+
+# 研判情报报告（大屏绘制智能体深链 selectSqReport）数据源：默认真实接口；真实接口未就绪可改 true 走本地样例假数据。
+VITE_MOCK_SQ_REPORT=false
+
+# Gateway / DeerFlow API
+VITE_BACKEND_BASE_URL=https://ch1.b.uat.4.cn/deerflow
+VITE_LANGGRAPH_BASE_URL=https://ch1.b.uat.4.cn/deerflow/api
+
+# 轻应用「新建笔记」系列接口
+VITE_NOTE_API_BASE_URL=https://your-intranet-host/note-api
+# CMZS后端接口
+VITE_API_BASE_URL=https://ch1.b.uat.4.cn/zncm
+# 佳来模型对话接口
+VITE_AIPI_CHAT_URL=https://ch1.b.uat.4.cn/gpt
+# 多轮检索接口
+VITE_AIPI_GENERATE_CHAT_URL=https://ch1.b.uat.4.cn/jialai_b1_chat
+VITE_AIPI_TASK_CHAT_URL=https://ch1.b.uat.4.cn/qq_b1_chat
+VITE_AIPI_KNOWLEDGE_URL=https://chlib.b.uat.4.cn/knowlibrary
+VITE_AIPI_B1COH_URL=https://ch1.b.uat.4.cn/web
+VITE_AIPI_B2ACTOR_URL=https://ty.b.uat.4.cn
+VITE_AIPI_B2ACTOR_XWT_PATH=/fromB/toXWT?isFrame=1
+VITE_AIPI_KNOWLEDGE_IFRAME_API_URL=https://ch1.b.uat.4.cn/knowes/api/iframeKnowledgeUrl
+VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
+VITE_AIPI_MOPECHAT_URL=https://ch1.b.uat.4.cn/likun_b1_mope
+# 工作室/空间后端接口（侧边栏“工作室”列表、空间详情等都走这里，不是 VITE_NOTE_API_BASE_URL）
+VITE_AIPI_BACKENP_URL=https://knowledgetoolserver.b.uat.4.cn
+# 我的空间前端
+VITE_AIPI_FRONTEND_URL= xxx
+VITE_AIPI_CONSUMER_URL=https://ch1.b.uat.4.cn/consumer
+# A 系统跳转地址（人物/组织/事件等列表项打开链接）
+VITE_AIPI_PRESENT_URL=https://present.a.uat.4.cn/present/domain
+# B 系统知识库 iframe 根地址
+VITE_AIPI_KNOWES_URL=https://ch1.b.uat.4.cn/knowes
+# MaxKey 鉴权（getTokenByOnlineTicket）
+VITE_AUTH_BASE_URL=https://auth.y.uat.4.cn
+VITE_AIPI_PGLINKTO_URL=https://pg.b.uat.4.cn
+VITE_AIPI_XKLINKTO_URL=https://kz.b.uat.4.cn
+# 工作室/空间前端地址（用于 auth/callback 等跳转）
+VITE_AIPI_FRONTEND_URL=https://knowledgetoolweb.b.uat.4.cn
+
+# 可选：Canvas 独立 LangGraph 地址
+# VITE_CANVAS_LANGGRAPH_BASE_URL=

frontend-web/.env.production.local.example

@@ -0,0 +1,7 @@
+# 复制为 .env.production.local，打包前临时覆盖生产地址（不提交 Git）
+
+# VITE_BACKEND_BASE_URL=https://your-intranet-host/deerflow
+# VITE_LANGGRAPH_BASE_URL=https://your-intranet-host/deerflow/api
+# VITE_NOTE_API_BASE_URL=https://your-intranet-host/note-api
+# VITE_AIPI_BACKENP_URL=https://your-notebook-backend-host
+# VITE_AIPI_FRONTEND_URL=https://your-notebook-frontend-host

frontend-web/.env.sit

@@ -0,0 +1,56 @@
+# SIT 环境打包（pnpm build:sit / npm run build:sit）— 接口地址为 UAT 的 sit 版本
+# 打包后变量会写入 dist，运行时不可再改
+
+# 任务看板数据源：true=真实接口（默认）；改成 false 可让任务分析/三情分析两页走本地假数据。
+VITE_USE_REAL_DATA=true
+
+# 任务详情（登录深链 cop-task-detail）数据源：默认真实接口；改成 true 走本地假数据（调试用）。
+VITE_MOCK_COP_TASK_DETAIL=false
+
+# 研判情报报告（大屏绘制智能体深链 selectSqReport）数据源：默认真实接口；真实接口未就绪可改 true 走本地样例假数据。
+VITE_MOCK_SQ_REPORT=false
+
+# 深链任务详情（cop-task-detail）数据源：默认真实接口；真实接口未就绪可改 true 走本地假数据。
+VITE_MOCK_COP_TASK_DETAIL=false
+
+# Gateway / DeerFlow API
+VITE_BACKEND_BASE_URL=https://ch1.b.sit.4.cn/deerflow
+VITE_LANGGRAPH_BASE_URL=https://ch1.b.sit.4.cn/deerflow/api
+
+# 轻应用「新建笔记」系列接口
+VITE_NOTE_API_BASE_URL=https://your-intranet-host/note-api
+# CMZS后端接口
+VITE_API_BASE_URL=https://ch1.b.sit.4.cn/zncm
+# 佳来模型对话接口
+VITE_AIPI_CHAT_URL=https://ch1.b.sit.4.cn/gpt
+# 多轮检索接口
+VITE_AIPI_GENERATE_CHAT_URL=https://ch1.b.sit.4.cn/jialai_b1_chat
+VITE_AIPI_TASK_CHAT_URL=https://ch1.b.sit.4.cn/qq_b1_chat
+VITE_AIPI_KNOWLEDGE_URL=https://chlib.b.sit.4.cn/knowlibrary
+VITE_AIPI_B1COH_URL=https://ch1.b.sit.4.cn/web
+VITE_AIPI_B2ACTOR_URL=https://ty.b.sit.4.cn
+VITE_AIPI_B2ACTOR_XWT_PATH=/fromB/toXWT?isFrame=1
+VITE_AIPI_KNOWLEDGE_IFRAME_API_URL=https://ch1.b.sit.4.cn/knowes/api/iframeKnowledgeUrl
+VITE_AIPI_KNOWLEDGE_IFRAME_SKIN=red
+VITE_AIPI_MOPECHAT_URL=https://ch1.b.sit.4.cn/likun_b1_mope
+# 工作室/空间后端接口（侧边栏“工作室”列表、空间详情等都走这里，不是 VITE_NOTE_API_BASE_URL）
+VITE_AIPI_BACKENP_URL=https://knowledgetoolserver.b.sit.4.cn
+VITE_NOTEBOOK_API_BASE_URL=https://knowledgetoolserver.b.sit.4.cn
+# 工作室侧边栏显示开关；仅控制入口显示，展开内容仍依赖 notebook 接口成功返回数据
+VITE_STUDIO_ENABLED=true
+# 工作室/笔记本前端地址（用于 auth/callback 等跳转）
+VITE_AIPI_FRONTEND_URL=https://knowledgetoolserver.b.sit.4.cn
+VITE_AIPI_CONSUMER_URL=https://ch1.b.sit.4.cn/consumer
+# A 系统跳转地址（人物/组织/事件等列表项打开链接）
+VITE_AIPI_PRESENT_URL=http://present.a.sit.4.cn/present/domain
+# B 系统知识库 iframe 根地址
+VITE_AIPI_KNOWES_URL=https://ch1.b.sit.4.cn/knowes
+# MaxKey 鉴权（getTokenByOnlineTicket）
+VITE_AUTH_BASE_URL=https://auth.y.sit.4.cn
+VITE_AIPI_PGLINKTO_URL=https://pg.b.sit.4.cn
+VITE_AIPI_XKLINKTO_URL=https://kz.b.sit.4.cn
+# 工作室/空间前端地址（用于 auth/callback 等跳转）
+VITE_AIPI_FRONTEND_URL=https://knowledgetoolserver.b.sit.4.cn
+
+# 可选：Canvas 独立 LangGraph 地址
+# VITE_CANVAS_LANGGRAPH_BASE_URL=

frontend-web/design-qa.md

@@ -0,0 +1,46 @@
+**Comparison target**
+
+- Source visual truth (dark intelligent-agent list): `C:/Users/董宏凯/AppData/Local/Temp/codex-clipboard-75f6ce1c-cd70-4b8c-a80a-a3d100105c69.png`
+- Additional source references: `C:/Users/董宏凯/AppData/Local/Temp/codex-clipboard-00567484-ba8a-4595-b386-52e1467ae9cf.png` (segmented switch), `C:/Users/董宏凯/AppData/Local/Temp/codex-clipboard-02808803-05ba-4f2c-be50-c72b484a9f06.png` (business-chain node card), `C:/Users/董宏凯/AppData/Local/Temp/codex-clipboard-adf38fec-7baf-4d01-9c73-bdbae94b774e.png` (business-chain selector)
+- Implementation screenshots: `C:/Users/董宏凯/AppData/Local/Temp/position-roundtable-revised-light.png`, `C:/Users/董宏凯/AppData/Local/Temp/position-roundtable-revised-dark.png`
+- Full-view comparison evidence: `C:/Users/董宏凯/AppData/Local/Temp/position-roundtable-revised-comparison.png`
+- Viewport: 1280 × 720. Light route: `#/page/strategy/qa/position-roundtable`; dark embedded route: `#/page/strategy/qa/position-roundtable?embed=1&theme=dark`.
+- State: local browser has no authenticated API session. The original intent API is invoked and reports `Authentication required`; business-chain and agent endpoints return no usable data.
+
+**Findings**
+
+- [P1] Populated agent and business-chain states cannot be compared yet.
+  Location: right agent list and non-planning-role chain diagram.
+  Evidence: reference images show populated cards and nodes; the implementation has `0 个` agents and no available business chain in the unauthenticated preview.
+  Impact: card density, selected-card indicator, chain node flow, and agent-detail transition cannot be truthfully verified against live data.
+  Fix: verify the route in an authenticated session with at least one public chain and tagged agents.
+
+**Open Questions**
+
+- The final business-chain stage arrangement is still pending product confirmation. The compact graph maps whatever stage configuration is returned, while intentionally omitting dependency-label text as requested.
+
+**Implementation Checklist**
+
+1. Left task panel is now display-only and retains its independent position-roundtable task adapter.
+2. Business-chain selection uses the original roundtable card/radio/relationship-entry pattern.
+3. Every position uses the original `useStep1Intent` interface and `Step1Panel` message list/input panel; only the position header changes.
+4. The right switch now uses the exact `课题研究 / ai写作` segmented-control treatment (light gray track, white active state; dark blue glass equivalent).
+5. The embedded layout widens the left panel to 360px and applies the deep-blue right-panel tokens used by the reference.
+6. Other roles render a taller top-to-bottom card-node flow without dependency labels. The canvas supports mouse-drag panning, and each node retains only a name plus a single-line description.
+
+**Follow-up Polish**
+
+- [P3] If live content is unusually long, tune the compact flow node width or horizontal scrolling after seeing the production chain data.
+
+**Comparison history**
+
+- Iteration 1: task fields were editable and the right TDesign card tabs looked unlike the reference. Replaced the task form with display-only information and replaced the tabs with the existing `课题研究 / ai写作` segmented switch.
+- Iteration 2: business-chain selection was a dropdown and the flow was vertical avatar chips. Replaced it with original-roundtable selection cards and compact business-chain configuration-style node cards with link lines but no dependency labels.
+- Iteration 3: dark right-panel background differed from the supplied deep-blue reference. Applied the `#032650` / `#042b59` / `#2b8ffe` token family and captured the revised embedded dark state in the full-view comparison.
+- Iteration 4: removed the custom disabled input from non-planning positions and reused the original roundtable input panel. Enlarged the left flow viewport, retained its connection lines, and removed node level/seat/status metadata.
+- Iteration 5: converted the compact flow from left-to-right to top-to-bottom. Added mouse-drag panning and single-line description truncation; populated-chain visual QA remains blocked by the unauthenticated preview.
+- Iteration 6: constrained the flow canvas to its card viewport, narrowed nodes from 190px to 158px, and realigned branch gaps plus connector anchors to prevent clipping and offset lines.
+
+**Final result**
+
+blocked

frontend-web/docs/AI_WRITING_BACKEND_DEV_ZH.md

@@ -1,916 +0,0 @@
-# AI 写作 — 后端开发文档
-
-> **本文档目的**：帮助后端开发者快速理解 AI 写作子系统的代码结构、Graph 拓扑、数据流、持久化、容错策略和扩展点。
->
-> **配套文档**：
-> - 前端：`frontend-web/docs/ai-writing-frontend-dev.md`
-> - 故障排查：`frontend-web/docs/ai-writing-说明.md`
-> - 前端 API 字段索引：`frontend-web/docs/ai-writing-assistant-backend-api.md`
-
----
-
-## 一、产品定位与技术架构
-
-### 产品定位
-**杂志社协作写作子系统**：由 4 个 AI Agent（**素材收集专家 / 作家 / 编辑 / 系统**）协作完成一篇文章，通过 4 个用户干预点参与决策。
-
-### 技术栈
-- **编排框架**：LangGraph（独立 StateGraph，不复用主 lead agent 的 middleware 链）
-- **节点驱动**：异步 LLM 调用（`langchain_openai` 等），支持流式 token 推送到 SSE
-- **状态持久化**：LangGraph checkpointer（SQLite 文件，跨重启可恢复）
-- **业务数据**：MySQL `ai_writing_sessions` 表
-- **协议**：SSE（Server-Sent Events）推进度 + REST 控制流
-
-### 与主 Agent 的关系
-**完全独立**。AI 写作 graph 不通过 `make_lead_agent` 也不走主 agent 的 18 层 middleware。它有自己的 StateGraph、自己的 checkpointer、自己的路由前缀（`/api/ai-writing/*`），跟主 agent 解耦。
-
----
-
-## 二、目录结构
-
-```
-offline-backend-20260512/backend/
-├── app/gateway/
-│   ├── routers/
-│   │   └── ai_writing.py                # FastAPI 路由 + 模块级状态字典 + SSE 生成器（1000+ 行，核心）
-│   ├── ai_writing_cleanup.py            # 定期清理 + cron 调度（独立模块）
-│   └── app.py                           # lifespan 启动/停止清理任务、检测多 worker、关闭 checkpointer
-│
-└── packages/harness/deerflow/
-    ├── agents/ai_writing/
-    │   ├── __init__.py                  # 暴露 AI_WRITING_GRAPH + 工厂函数
-    │   ├── graph.py                     # ⭐ StateGraph 定义 + 4 个 pause 节点 + checkpointer 工厂（538 行）
-    │   ├── state.py                     # AIWritingState TypedDict（121 行）
-    │   │
-    │   ├── nodes/                        # ── Graph 节点 ──
-    │   │   ├── _utils.py                # LLM 工具：parse_json, ThinkTagParser, llm_json
-    │   │   ├── intent_parser.py         # 节点 1：意图解析
-    │   │   ├── researcher.py            # 节点 2：素材检索（支持流式 progress）
-    │   │   ├── writer_outline.py        # 节点 3：大纲规划
-    │   │   ├── writer_draft.py          # 节点 4：草稿生成（按章节流式）
-    │   │   └── editor.py                # 节点 5：编辑审核（3 维度并行流式）
-    │   │
-    │   ├── prompts/                      # ── Prompt 模板 ──
-    │   │   ├── __init__.py
-    │   │   ├── researcher_prompts.py
-    │   │   ├── writer_prompts.py
-    │   │   └── editor_prompts.py
-    │   │
-    │   └── search/                       # ── 素材检索 provider ──
-    │       ├── base.py                   # SearchResult / SearchProvider 接口
-    │       ├── duckduckgo_search.py
-    │       ├── internet_search.py        # 互联网检索（默认）
-    │       ├── intranet_stub.py          # 内网检索占位（按部署接入）
-    │       └── demo_search.py            # 离线 demo 数据
-    │
-    └── persistence/ai_writing_sessions/
-        ├── __init__.py                   # AIWritingSessionRepository 工厂
-        ├── model.py                      # ORM：AIWritingSessionRow
-        └── sql.py                        # CRUD 实现（含清理用的 list_older_than / delete_by_ids）
-```
-
----
-
-## 三、Graph 拓扑（最重要）
-
-### StateGraph 节点 + 边
-
-```
-                     START
-                       │
-                       ↓
-              ┌─────────────────┐
-              │  intent_parser  │   解析用户意图（确定 article_type / target_audience）
-              └────────┬────────┘
-                       ↓
-              ┌─────────────────┐
-              │   researcher    │   ← (re_search 回到这里)
-              └────────┬────────┘
-                       ↓ (after_researcher: ⼟材 ready)
-              ┌──────────────────────┐
-              │  pause_material      │   ⚙️ PAUSE-1：素材确认
-              └─┬──────────┬─────────┘
-                │ confirm  │ re_search
-                ↓          └→ researcher
-              ┌─────────────────┐
-              │ writer_outline  │   ← (re_outline 回到这里)
-              └────────┬────────┘
-                       ↓
-              ┌──────────────────────┐
-              │  pause_outline       │   ⚙️ PAUSE-2：大纲确认
-              └─┬──────────┬─────────┘
-                │ confirm  │ re_outline
-                ↓          └→ writer_outline
-              ┌─────────────────┐
-              │  writer_draft   │   ← (素材补充后回到这里)
-              └─┬───────────────┘
-                ↓ (after_writer_draft)
-        ┌──────┴────────────────┐
-        ↓                       ↓
-  ┌──────────────────┐   ┌────────────────────┐
-  │ pause_section_   │   │ pause_draft        │   ⚙️ PAUSE-3：草稿确认
-  │ help（素材不足）│   │                    │
-  └─┬─────────────┬──┘   └─┬────────┬───┬─────┘
-    │ supplement  │ del/    │        │   │ to_editor
-    │↓            │ loose   │        │ user_revise
-    research     writer_     │ final  ↓
-                  draft     │ ize   writer_draft
-                            │↓
-                            done
-                                       │
-                            (to_editor)│
-                                       ↓
-                              ┌─────────────────┐
-                              │     editor      │   3 维度并行流式审核
-                              └────────┬────────┘
-                                       ↓ (after_review)
-                              ┌──────────────────────┐
-                              │  pause_review        │   ⚙️ PAUSE-4：审核确认
-                              └─┬──────────┬─────────┘
-                                │ confirm  │ revise
-                                │↓         └→ writer_draft
-                              done
-```
-
-### 节点定义位置一览
-
-| 节点名 | 实现文件 | 类型 | 流式? |
-|---|---|---|---|
-| `intent_parser` | `nodes/intent_parser.py` | async function | 否 |
-| `researcher` | `nodes/researcher.py` | async function | 是（research_progress） |
-| `pause_material` | `graph.py` 顶部 | async, 调 `interrupt()` | — |
-| `writer_outline` | `nodes/writer_outline.py` | async function | 是（outline_chunk） |
-| `pause_outline` | `graph.py` 顶部 | async, 调 `interrupt()` | — |
-| `writer_draft` | `nodes/writer_draft.py` | async function | 是（draft_chunk，按章节） |
-| `pause_section_help` | `graph.py` 顶部 | async, 调 `interrupt()` | — |
-| `pause_draft` | `graph.py` 顶部 | async, 调 `interrupt()` | — |
-| `editor` | `nodes/editor.py` | async function | 是（review_chunk，3 路并行） |
-| `pause_review` | `graph.py` 顶部 | async, 调 `interrupt()` | — |
-
-### 条件路由函数（graph.py）
-
-| 函数 | 在哪个节点之后 | 路由依据 |
-|---|---|---|
-| `after_researcher` | researcher | 是否找到素材 |
-| `after_material_pause` | pause_material | `state["status"]` 是 researching 还是 writing_outline |
-| `after_outline_pause` | pause_outline | 同上，writing_outline 还是 writing_draft |
-| `after_writer_draft` | writer_draft | 是否有 blocked_sections |
-| `after_section_help_pause` | pause_section_help | status |
-| `after_draft_pause` | pause_draft | done / revising / reviewing |
-| `after_review` | editor | review_result.verdict 是 pass 还是 reject + revision_count 上限 |
-| `after_review_pause` | pause_review | done / writing_draft |
-
----
-
-## 四、State 定义（state.py）
-
-```python
-class AIWritingState(TypedDict):
-    # —— 写作配置（启动时填充）——
-    user_intent: str
-    article_type: str
-    target_audience: str
-    word_count_target: int
-    keyword_count: int            # 1-10，默认 6
-    writing_mode: str             # "strict" | "loose"
-
-    # —— Agent 产出 ——
-    material_package: Optional[MaterialPackage]      # 素材收集专家
-    current_outline: Optional[Outline]               # 作家
-    drafts: Annotated[List[DraftArticle], operator.add]  # 累计所有版本
-    current_draft: Optional[DraftArticle]            # 最新草稿
-    review_result: Optional[ReviewResult]            # 编辑
-
-    # —— 用户干预 ——
-    last_user_intervention: Optional[UserInterventionPayload]
-    blocked_sections: Optional[List[BlockedSection]]  # 素材不足的章节
-
-    # —— 流程控制 ——
-    revision_count: int
-    max_revisions: int            # 默认 3
-    status: WritingStatus
-
-    # —— SSE 推送队列 ——
-    progress_events: Annotated[List[dict], operator.add]  # 累加，不覆盖
-```
-
-### State 字段的特殊语义
-
-- **`Annotated[..., operator.add]`** — LangGraph 的累加 reducer，节点 return 时 `progress_events: [evt]` 会**追加**到现有列表，而不是替换
-- **TypedDict** — 运行时是普通 dict，类型注解仅供 IDE 提示
-- **节点输出** — 节点 return 的 dict 只需要包含**要更新的字段**，未指定的字段保持不变
-
----
-
-## 五、路由层（app/gateway/routers/ai_writing.py）
-
-### 14 个接口一览
-
-| HTTP | 路径 | 用途 | 鉴权 |
-|---|---|---|---|
-| POST | `/api/ai-writing/start` | 启动写作，返回 session_id | 用户 |
-| GET | `/api/ai-writing/{id}/stream` | SSE 进度流 | 用户 |
-| POST | `/api/ai-writing/{id}/resume` | 提交用户干预 | 用户 |
-| GET | `/api/ai-writing/{id}/state` | 查 graph 状态快照（调试用） | 用户 |
-| GET | `/api/ai-writing/sessions` | 列出当前用户的历史会话 | 用户 |
-| GET | `/api/ai-writing/sessions/{id}` | 获取单个历史会话 | 用户 |
-| PATCH | `/api/ai-writing/sessions/{id}` | 重命名会话 | 用户 |
-| DELETE | `/api/ai-writing/sessions/{id}` | 删除会话 | 用户 |
-| PUT | `/api/ai-writing/sessions/{id}/transcript` | 保存对话时间线（**fire-and-forget**） | 用户 |
-| GET | `/api/ai-writing/article-types` | 列出文章类型 | 用户 |
-| POST | `/api/ai-writing/article-types` | 新增文章类型 | 用户（建议改成 admin） |
-| PATCH | `/api/ai-writing/article-types/{id}` | 更新文章类型 | 用户 |
-| DELETE | `/api/ai-writing/article-types/{id}` | 删除文章类型 | 用户 |
-| POST | `/api/ai-writing/admin/cleanup` | **手动触发清理** | admin only |
-
-### 模块级状态字典（关键设计 — 也是 worker 限制的根源）
-
-```python
-# 每个 session_id 对应一份内存状态。多 worker 部署时每个 worker 一份，互不共享。
-_event_queues:          dict[str, asyncio.Queue]  # SSE 事件队列
-_session_pending_pause: dict[str, tuple]          # 挂起的 await_user 事件（供重连重投）
-_session_model_names:   dict[str, str]            # 用户选的模型
-_session_interventions: dict[str, list]           # 累计干预历史
-_session_repos:         dict[str, repo]           # DB 仓库引用
-_session_user_ids:      dict[str, str]            # 用户 id
-_session_article_types: dict[str, list]           # 动态文章类型列表
-_session_error_flags:   dict[str, bool]
-_inflight_graph_tasks:  set[asyncio.Task]          # in-flight task 注册表（lifespan drain 用）
-_recovery_lock:         asyncio.Lock              # 跨 worker 会话恢复的并发锁
-```
-
-⚠️ **关键限制**：这些都是 per-process 内存。多 worker 部署下，worker B 看不到 worker A 的状态 → SSE 事件分发失败。详见 `frontend-web/docs/ai-writing-说明.md` 第五、六章。
-
-### `_stream_graph_segment`（graph 推进函数）
-
-`/start` 和 `/resume` 都调用这个函数（用 `_spawn_graph_task` 包装），负责：
-1. 调 `graph.astream(input_or_command, config=config, stream_mode="updates")`
-2. 把每个 chunk 解析成 SSE 事件 put 进 `_event_queues[session_id]`
-3. 遇到 `__interrupt__` → 推 `await_user` 事件 → 返回（不关闭 queue）
-4. 遇到 END → 推 `done` 事件 → 关闭 queue（put None 哨兵）
-5. 任何异常 → 推 `error` 事件 → 关闭 queue
-6. finally 段：更新 DB 最终状态、清理所有模块字典
-
-### SSE 生成器 `_sse_generator`
-
-`GET /stream` 的实现，从 `_event_queues[session_id]` 拿事件 → `_sse(event, data)` 序列化 → yield 给 fastapi `StreamingResponse`。
-
-**关键逻辑**：
-- 队列不存在时**等待 5 秒**，期间触发 `_recover_session`（跨 worker / 进程重启恢复）
-- `_sse()` 三层兜底：`default=str` → 手写 notice 帧 → 永不抛 TypeError
-- 收到 None 哨兵 → 关闭流
-
-### `_recover_session`（跨 worker 恢复）
-
-当 worker 内存里没有 session_id 但 sqlite checkpointer 有快照时：
-1. 从 checkpointer 读出 state snapshot
-2. 重建 `_event_queues[sid]` 队列
-3. 从 snapshot 提取当前 interrupt 负载，put 进队列
-4. 同时尽量恢复 `_session_repos`、`_session_user_ids` 等
-
-返回三种状态：
-- `"interrupted"` — 图停在干预点，已重建队列
-- `"finished"` — 图已完成或中断在节点中间，推 done/error 事件后关闭
-- `"unrecoverable"` — sqlite 也没有这个 thread_id → 真的丢了
-
-### `_spawn_graph_task` / `wait_for_inflight_graph_tasks`（优雅关闭）
-
-- `_spawn_graph_task(coro)` — 启 task 并自动登记到 `_inflight_graph_tasks`，完成时反登记
-- `wait_for_inflight_graph_tasks(timeout)` — lifespan shutdown 等所有 task 跑到下一个 interrupt / END（默认 30s），超时则 cancel 强制结束
-
----
-
-## 六、Graph 与持久化（graph.py）
-
-### Lazy 单例 + 自动降级
-
-```python
-AI_WRITING_GRAPH = None                      # 模块级槽位（测试可 monkeypatch）
-_async_checkpointer_singleton = None         # checkpointer 单例
-
-async def get_ai_writing_graph():
-    """懒加载 graph。第一次调用时按 config.yaml 决定 checkpointer。"""
-    global AI_WRITING_GRAPH
-    if AI_WRITING_GRAPH is not None:
-        return AI_WRITING_GRAPH
-    checkpointer = await _get_async_checkpointer()
-    AI_WRITING_GRAPH = build_ai_writing_graph(checkpointer=checkpointer)
-    return AI_WRITING_GRAPH
-```
-
-### Checkpointer 优先级（_get_async_checkpointer）
-
-```
-1. config.yaml 的 checkpointer 段
-   ├── type: sqlite    → AsyncSqliteSaver(aiosqlite.connect(...))
-   ├── type: postgres  → AsyncPostgresSaver(AsyncConnectionPool(...))
-   └── type: memory    → InMemorySaver
-
-2. 任何初始化失败                 → InMemorySaver（降级，打 warning）
-3. 未配置 checkpointer 段         → InMemorySaver（降级，打 warning）
-4. 未知 type（如 "mysql"）         → InMemorySaver（降级，打 warning）
-```
-
-**核心契约**：`_get_async_checkpointer()` **绝不抛异常**，永远返回一个可用的 saver。这是「写作流程能完整继续」契约的关键。
-
-### Shutdown
-
-`shutdown_ai_writing_graph()` 在 lifespan shutdown 时调用：
-- 关闭 `aiosqlite.Connection` / `AsyncConnectionPool`
-- 清空 `AI_WRITING_GRAPH` / `_async_checkpointer_singleton`
-
-调用顺序（详见 `app/gateway/app.py` lifespan）：
-1. 停清理任务
-2. `wait_for_inflight_graph_tasks(30s)`
-3. `shutdown_ai_writing_graph()`
-
----
-
-## 七、节点详解（nodes/）
-
-### `nodes/_utils.py`（公共工具）
-
-| 函数 / 类 | 用途 |
-|---|---|
-| `get_model(config, model_name)` | 从 config.configurable 拿 model_name 或回退默认 |
-| `parse_json(text, fallback)` | 鲁棒 JSON 解析（支持代码块、不完整 JSON、转义错误） |
-| `_extract_balanced(text)` | 找出第一对平衡的 `{...}` |
-| `_repair_json(text)` | 修复常见的 JSON 错误（缺尾引号等） |
-| `ThinkTagParser` | 流式解析 `<think>...</think>` 标签（思考 / 正文分流） |
-| `llm_json(system, user, fallback, config)` | 调 LLM 并解析 JSON 输出 |
-| `count_words(text)` | 中文 + 英文混合计字数 |
-
-### `nodes/intent_parser.py` — 意图解析
-
-- 调 LLM 把用户意图（`user_intent` 字符串）解析成结构化字段：`article_type`、`target_audience`、`word_count_target`
-- 用户已经在 `AIWritingRequest` 里指定的字段会**覆盖** LLM 推断
-- 输出：更新 state 的对应字段，推 `step_done` 事件
-
-### `nodes/researcher.py` — 素材检索
-
-- 根据 `user_intent` 用 LLM 生成 N 个关键词（N = `keyword_count`，默认 6）
-- 用 `search/*` 的 provider 并行检索
-- 流式推 `research_progress` 事件（"正在搜索关键词 X 中..."）
-- 输出：`material_package = {keywords, materials, summary}`，推 `materials_ready`
-
-### `nodes/writer_outline.py` — 大纲规划
-
-- 输入：`user_intent` + `material_package`
-- 调 LLM 流式生成大纲 JSON，期间推 `outline_chunk`（正文 + thinking 分流）
-- 解析最终 JSON → `current_outline`，推 `outline_ready`
-
-### `nodes/writer_draft.py` — 草稿生成（最复杂）
-
-- 按大纲**逐章节**调 LLM 生成正文，每章节独立流式推 `draft_chunk`
-- 检测 LLM 是否「拒答」（`_looks_like_refusal`），如果是则换提示重试
-- **严格模式下**：如果章节关联的素材不足，把该章节加入 `blocked_sections`，触发 `pause_section_help`
-- 完成所有章节后拼成 `current_draft.full_markdown`，推 `draft_ready`
-
-### `nodes/editor.py` — 编辑审核（3 维度并行）
-
-- 3 个维度（**fact / logic / language**）并行调 LLM
-- 每个维度独立流式推 `review_chunk`，完成后推 `review_item_done`
-- 三个都完成后聚合成 `review_result`，推 `review_ready`
-- 评分加权（fact 40% + logic 30% + language 30%），超过 `pass_threshold`（默认 80）verdict = `pass`
-
----
-
-## 八、持久化（persistence/ai_writing_sessions/）
-
-### `model.py` — ORM
-
-```python
-class AIWritingSessionRow(Base):
-    __tablename__ = "ai_writing_sessions"
-    id: Mapped[str]                        # = session_id（uuid）
-    user_id: Mapped[str | None]            # NULL = no-auth 模式
-    title: Mapped[str]                     # 从 user_intent 截取前 50 字
-    user_intent: Mapped[str | None]
-    status: Mapped[str]                    # in_progress / draft_ready / review_ready / done / error
-    draft_title: Mapped[str | None]
-    draft_markdown: Mapped[str | None]
-    completed_interventions: Mapped[str | None]   # JSON 字符串
-    review_result: Mapped[str | None]              # JSON 字符串
-    transcript: Mapped[str | None]                 # PortableLongText（MySQL→LONGTEXT，4GB）
-    created_at / updated_at: BeijingDateTime
-```
-
-### `sql.py` — Repository
-
-| 方法 | 用途 |
-|---|---|
-| `create(id, title, user_intent, user_id)` | 启动写作时建一行 |
-| `get(session_id, user_id)` | 取单个（带 user_id 权限校验） |
-| `list(user_id, limit)` | 列出当前用户的会话 |
-| `update(session_id, user_id, ...)` | 更新指定字段（其他保持不变） |
-| `delete(session_id, user_id)` | 删除（带权限校验） |
-| `list_older_than(cutoff, only_finished, limit)` | 清理用：列出过期 session_id |
-| `delete_by_ids(session_ids)` | 清理用：批量删除 |
-
-### Alembic 迁移
-
-- `20260517_03_ai_writing_transcript.py` — 加 transcript 列（TEXT）
-- `20260519_02_ai_writing_transcript_longtext.py` — MySQL 上把 transcript 改成 LONGTEXT（修 64KB 限制导致的 500）
-
----
-
-## 九、定期清理（ai_writing_cleanup.py）
-
-### 设计目标
-- 删超过 `retention_days`（默认 7）的旧会话
-- 联动清理：MySQL 业务行 + SQLite checkpointer 里的 thread 状态
-- **绝对不删正在写的会话**（活跃保护）
-
-### 关键函数
-
-```python
-async def run_cleanup_once(*, retention_days, only_finished=False, batch_size=500) -> dict
-```
-
-返回 `{deleted_db, deleted_checkpoints, skipped_active}`。
-
-执行流程：
-1. 调 `repo.list_older_than(cutoff, only_finished, batch_size)` 拿过期 id
-2. 从 `_event_queues.keys()` 拿活跃 session_id 集合 → **过滤掉所有仍在跑的**
-3. 对每个待删 id：调 `checkpointer.adelete_thread(id)` 删 checkpoint
-4. 调 `repo.delete_by_ids(ids)` 批量删 MySQL
-5. 循环直到本批 < batch_size
-
-### Cron 调度
-
-`cleanup_scheduler_loop()` 常驻后台任务：
-- 用 `croniter` 解析 `ai_writing.cleanup.cron`（默认 `"0 3 * * *"`，每天凌晨 3 点）
-- `asyncio.sleep` 到下次触发时间
-- 多 worker 用文件锁（`runtime_home() / ".ai_writing_cleanup.lock"`）做 leader election
-
-### Admin 手动触发
-
-`POST /api/ai-writing/admin/cleanup`：
-- 鉴权：`system_role == "admin"`
-- 可选覆盖 `retention_days` / `only_finished` / `batch_size`
-- 即使传 `retention_days: 0` 也不会秒杀活跃会话（活跃保护硬保证）
-
----
-
-## 十、配置（config.yaml）
-
-```yaml
-# Checkpointer：graph 状态持久化
-checkpointer:
-  type: sqlite                           # sqlite | postgres | memory
-  connection_string: .deer-flow/data/checkpoints.db
-
-# AI 写作子系统
-ai_writing:
-  # ── 清理调度 ─────────────────────────────────────────────
-  cleanup:
-    enabled: true
-    retention_days: 7
-    cron: "0 3 * * *"                    # 每天凌晨 3 点
-    delete_only_finished: false
-    batch_size: 500
-
-  # ── 素材收集专家（researcher）专用配置 ──────────────────
-  # 这两个模型名必须出现在顶层 models[] 段里；留空 / 不配则回退当前写作主模型。
-  # 拆出来是为了让「检索词生成 / 素材排序」这种结构化抽取任务可以走更轻量、
-  # 不带思考输出的小模型，省钱省时间，也避开写作主模型的思考干扰。
-  keyword_model: qwen3-4b-instruct       # 检索词生成（EXTRACT_KEYWORDS_*）
-  rank_model:    qwen3-4b-instruct       # 素材排序筛选（RANK_MATERIALS_*）
-
-  # 素材总量上限：合并去重后保留多少条素材进入大纲 / 草稿阶段
-  # 取值范围 [1, 100]，非法值或缺省回退 20。
-  # 每个检索词分到的检索条数 = ceil(max_materials / keyword_count)，
-  # 所以这个数越大，每个关键词向 provider 拉的条数越多，整体耗时也越长。
-  max_materials: 20
-
-  # ── 素材检索 provider ───────────────────────────────────
-  # internet(默认,DuckDuckGo) / intranet(内网 ES) / tavily / demo
-  search_provider: internet
-
-  # internet 模式：DuckDuckGo 区域代码（cn-zh / us-en / wt-wt 等）
-  ddg_region: "cn-zh"
-
-  # intranet 模式：对接内网知识库 ES 检索接口
-  # 接口契约（POST）：
-  #   payload  = {"query": "...", "knowledge_base_name": "<intranet_knowledge_base>", "ts": "yes"}
-  #   response = [{"page_content": "...", "metadata": {m_title, content, recUuid, m_publish, source1}}]
-  # 实现见 packages/harness/deerflow/agents/ai_writing/search/intranet_stub.py
-  intranet_search_url: http://10.106.57.180:7863/knowledge_base/search_docs_es
-  intranet_knowledge_base: samples       # 默认 samples，按部署的实际知识库名改
-```
-
-### 配置项与代码的对应关系
-
-| 配置键 | 默认值 | 取值范围 / 说明 | 读取位置 |
-|---|---|---|---|
-| `ai_writing.keyword_model` | 空（回退写作主模型） | 必须是 `models[]` 段里已声明的模型名 | `nodes/researcher.py` → `llm_json(..., model_name=keyword_model)` |
-| `ai_writing.rank_model` | 空（回退写作主模型） | 同上 | `nodes/researcher.py` → 排序分支 `llm_json(..., model_name=rank_model)` |
-| `ai_writing.max_materials` | `20` | `[1, 100]`，非法值回退 20；`_resolve_max_materials` 钳制 | `nodes/researcher.py:_DEFAULT_MAX_MATERIALS` |
-| `ai_writing.search_provider` | `"internet"` | `internet` / `intranet` / `tavily` / `demo` | `search/__init__.py:get_search_provider` |
-| `ai_writing.ddg_region` | `"cn-zh"` | DuckDuckGo 区域代码，仅 `internet` 模式生效 | 同上 |
-| `ai_writing.intranet_search_url` | `http://10.106.57.180:7863/knowledge_base/search_docs_es` | 仅 `intranet` 模式生效，POST JSON 接口 | `search/intranet_stub.py:_DEFAULT_ENDPOINT` |
-| `ai_writing.intranet_knowledge_base` | `"samples"` | 仅 `intranet` 模式生效，知识库 ID/名称 | 同上 |
-
-### 配置如何传到节点
-
-```
-config.yaml
-   └─ ai_writing: { ... }
-         │
-         ▼  _ai_writing_config() 取出整个 dict
-   routers/ai_writing.py:_make_config()
-         │  注入到 config.configurable.ai_writing_config
-         ▼
-   nodes/researcher.py
-     cfg = config.get("configurable", {})
-     ai_writing_config = cfg.get("ai_writing_config", {})
-     keyword_model = ai_writing_config.get("keyword_model")
-     rank_model    = ai_writing_config.get("rank_model")
-     max_materials = _resolve_max_materials(ai_writing_config.get("max_materials"))
-     provider      = get_search_provider(ai_writing_config)   # ← search_provider 等也从这里读
-```
-
-### 切换内网检索的最小步骤
-
-1. `config.yaml` 改 `ai_writing.search_provider: intranet`
-2. 填 `intranet_search_url` 和 `intranet_knowledge_base`（部署侧给）
-3. 内网 ES 接口若返回结构异常 / 网络抖动，researcher 节点会收集 `provider.errors` + `provider.raw_responses`，作为非致命 `notice` 事件推前端时间线（折叠显示原始响应体），**不会中断写作流程**
-4. 健康检查：可通过 `IntranetSearchProvider.health_check()` 单测，或直接发一笔 `/start` 看 `research_progress` 是否报错
-
-### 备注
-
-- `keyword_model` / `rank_model` 只影响素材收集专家的 LLM 调用，**不影响**大纲、草稿、编辑审核三个节点（它们各自走自己的主模型）。
-- `max_materials` 是「合并去重后的总量上限」，不是每个关键词的检索条数；每个词的检索数会按 `ceil(max_materials / keyword_count)` 均分。`keyword_count` 由前端启动写作时传入（1~10，默认 6）。
-- `intranet` 模式不带 fallback；如果内网 ES 全挂，researcher 拿到空结果会直接进入「未检索到素材，可重新搜索或在无素材的情况下继续写作」分支。如果想让内网失败时退回互联网检索，需要在 `get_search_provider` 里手动用 `_FallbackSearchProvider(IntranetSearchProvider(...), DuckDuckGoSearchProvider(...))` 包一层。
-
-ai_writing:
-  keyword_model: deepseek-chat       # 检索词生成专用模型，留空回退写作主模型
-  rank_model: deepseek-chat          # 素材排序专用模型，留空回退写作主模型
-  max_materials: 50                  # 合并去重后的素材总量上限，范围 [1, 100]，默认 20
-
----
-
-## 十一、SSE 事件协议（后端 → 前端契约）
-
-后端通过 `_sse(event_type, data)` 推 `event: <type>\ndata: <json>\n\n` 格式。
-
-### 推出事件的位置
-
-| 事件 | 推出位置 |
-|---|---|
-| `connected` | `_sse_generator` 入口 |
-| `step_start` / `step_done` | 节点内部主动 emit |
-| `research_progress` | `researcher_node` 内的 `_emit` |
-| `materials_ready` | `_stream_graph_segment` 检测到 `material_package` 字段 |
-| `outline_chunk` | `writer_outline_node` 流式推（通过 `sse_queue`） |
-| `outline_ready` | `_stream_graph_segment` 检测到 `current_outline` |
-| `draft_chunk` | `writer_draft_node` 按章节流式推 |
-| `draft_ready` | `_stream_graph_segment` 检测到 `current_draft` |
-| `review_chunk` / `review_item_done` | `editor_node` 3 维度并行流式 |
-| `review_ready` | `_stream_graph_segment` 检测到 `review_result` |
-| `await_user` | `_stream_graph_segment` 捕获 `__interrupt__` |
-| `resumed` | pause 节点 return 时塞进 `progress_events` |
-| `notice` | 节点内手动推（非致命告警） |
-| `done` | `_stream_graph_segment` 正常结束 |
-| `error` | `_stream_graph_segment` except 分支 |
-
-### 节点如何流式推 chunk
-
-通过 `config.configurable.sse_queue`：
-
-```python
-async def writer_outline_node(state, config):
-    sse_queue = config.get("configurable", {}).get("sse_queue")
-    sse_session_id = config.get("configurable", {}).get("sse_session_id")
-    
-    async for chunk in llm.astream(prompt):
-        if sse_queue:
-            await sse_queue.put(("outline_chunk", {
-                "session_id": sse_session_id,
-                "text": chunk.content,
-                "is_thinking": False,
-            }))
-    
-    return {"current_outline": parsed, ...}
-```
-
-`sse_queue` 是路由层在 `_make_config` 里注入的 `_event_queues[session_id]`。
-
----
-
-## 十二、扩展指南：常见开发任务
-
-### 任务 1：新增一个 Graph 节点
-
-**例**：在 `editor` 之后加一个「术语统一」节点。
-
-1. **写节点**：在 `nodes/` 新建 `terminology.py`：
-   ```python
-   async def terminology_node(state, config):
-       # ... 读 current_draft 改术语
-       return {
-           "current_draft": new_draft,
-           "progress_events": [{"type": "step_done", "agent_name": "术语统一", "message": "..."}],
-       }
-   ```
-
-2. **注册到 graph**：在 `graph.py` 的 `build_ai_writing_graph` 里：
-   ```python
-   from .nodes.terminology import terminology_node
-   g.add_node("terminology", terminology_node)
-   # 改 editor 后的边
-   g.add_edge("editor", "terminology")
-   g.add_edge("terminology", "pause_review")
-   ```
-
-3. **State 加字段**（如果需要）：`state.py` 加新字段到 `AIWritingState`
-
-4. **前端事件支持**（如果要新事件类型）：见前端文档「扩展指南」
-
-5. **测试**：在 `tests/` 加单元测试，至少测节点能正常 return 和 graph 拓扑能编译
-
-### 任务 2：新增一个用户干预点
-
-1. **写 pause 节点**：在 `graph.py` 顶部加：
-   ```python
-   async def pause_xxx(state):
-       user_input = interrupt({
-           "pause_point": "xxx_confirm",
-           "message": "...",
-           "context_field": state["..."],
-       })
-       action = user_input.get("action", "confirm")
-       if action == "confirm":
-           return {"status": "next_status", "progress_events": [{"type": "resumed", ...}]}
-       # ... 其他分支
-   ```
-
-2. **路由层 ResumeRequest 加字段**（如果干预需要新字段）：
-   ```python
-   class ResumeRequest(BaseModel):
-       # ...
-       new_field: Optional[str] = None
-   ```
-
-3. **`resume_writing` 路由把字段塞进 Command(resume=...)**：
-   ```python
-   intervention = {
-       # ...
-       "newField": body.new_field,
-   }
-   ```
-
-4. **graph 拓扑加 pause 节点的边**：在 build_ai_writing_graph 里
-
-5. **前端配合**：见前端文档
-
-### 任务 3：新增一种素材检索 provider
-
-1. 在 `agents/ai_writing/search/` 加新文件，实现 `SearchProvider` 接口（参考 `internet_search.py`）：
-   ```python
-   class MyProvider(SearchProvider):
-       async def search(self, keyword: str, limit: int) -> list[SearchResult]:
-           ...
-   ```
-
-2. 配置 `config.yaml`：
-   ```yaml
-   ai_writing:
-     search:
-       provider: my_pkg.search:MyProvider
-       # provider 特定的配置...
-   ```
-
-3. `researcher_node` 通过 `config.configurable.ai_writing_config.search.provider` 用 `resolve_class` 动态加载
-
-### 任务 4：修改 LLM Prompt
-
-所有 prompt 集中在 `agents/ai_writing/prompts/`：
-- `researcher_prompts.py` — 检索专家
-- `writer_prompts.py` — 大纲 + 草稿
-- `editor_prompts.py` — 审核
-
-改 prompt 后**强烈建议**：
-1. 在 `tests/` 加针对该 prompt 输出的回归测试（用 LLM mock 或固定输入）
-2. 跑现有测试确认拓扑兼容
-
-### 任务 5：扩展持久化字段
-
-例：给 `ai_writing_sessions` 加一个 `total_tokens` 列。
-
-1. `model.py` 加列：
-   ```python
-   total_tokens: Mapped[int | None] = mapped_column(Integer, nullable=True)
-   ```
-
-2. **必须**新建 alembic 迁移：
-   ```bash
-   PYTHONPATH=. uv run alembic revision -m "add total_tokens column"
-   ```
-   然后填 upgrade/downgrade 逻辑（参考 `20260519_02_ai_writing_transcript_longtext.py`）
-
-3. `sql.py` 的 `update()` / `to_dict()` 加字段处理
-
-4. `routers/ai_writing.py` 的 `SessionResponse` 加字段
-
-5. 测试：在 `tests/test_ai_writing_session_repo.py` 加新字段的 round-trip 测试
-
----
-
-## 十三、容错策略（关键设计原则）
-
-### 「写作流程能完整继续」契约
-
-后端承诺：**除非 Pydantic 校验失败（4xx），AI 写作的 4 个核心接口任何后端组件失败都不阻断当次写作的完整执行**。
-
-### 落实位置
-
-| 失败点 | 兜底位置 | 行为 |
-|---|---|---|
-| sqlite checkpointer 初始化失败 | `_get_async_checkpointer` | 自动降级 InMemorySaver |
-| SSE JSON 序列化失败 | `_sse()` | 三层兜底（default=str → notice 帧） |
-| DB `create()` session 行失败 | `start_writing` | try/except 吞掉，session_id 仍返回 |
-| DB `update(draft)` 失败 | `_stream_graph_segment` | try/except 吞掉，graph 继续推 |
-| DB `update(review)` 失败 | 同上 | 同上 |
-| DB `update(transcript)` 失败 | `save_transcript` 路由 | 返回 `success=false`，不抛 5xx |
-| 文章类型加载失败 | `start_writing` | 退回 `[]` |
-| Graph 编译失败 | `start_writing` | 抛 503（极端情况，节点 import 错） |
-| Graph 运行时节点抛错 | `_stream_graph_segment` | except 推 error 事件，session 结束 |
-| Cleanup 误删活跃会话 | `run_cleanup_once` | 活跃保护硬过滤 |
-
-### 容器优雅关闭
-
-lifespan shutdown 顺序：
-1. 停 cleanup scheduler
-2. `wait_for_inflight_graph_tasks(30s)` — 等所有 in-flight 写作跑到下一个 checkpoint
-3. 超时未结束的 task `cancel()` + 2s ack 等待
-4. `shutdown_ai_writing_graph()` — 关闭 aiosqlite Connection / pg pool
-
----
-
-## 十四、测试覆盖
-
-| 测试文件 | 数量 | 覆盖范围 |
-|---|---|---|
-| `tests/test_ai_writing_session_repo.py` | 7 | Repo CRUD + 清理用的 list_older_than / delete_by_ids |
-| `tests/test_ai_writing_session_recovery.py` | 8 | `_recover_session` / `_extract_interrupt` / `resume_writing` 跨 worker 恢复 |
-| `tests/test_ai_writing_transcript_endpoint.py` | 5 | transcript 保存兜底 |
-| `tests/test_ai_writing_cleanup.py` | 26 | 清理 + drain + checkpointer 降级 + SSE 序列化 + admin 接口 + 多 worker 检测 |
-| `tests/test_portable_long_text.py` | 5 | LONGTEXT 列类型 + 迁移链 |
-
-跑全部：
-```bash
-PYTHONPATH=. uv run pytest tests/test_ai_writing*.py tests/test_portable_long_text.py -v
-```
-
-期望 **51 个测试全过**。
-
----
-
-## 十五、关键调试 / 排查命令
-
-### 看 graph 当前状态
-
-```python
-# 进 python shell
-from deerflow.agents.ai_writing.graph import get_ai_writing_graph
-graph = await get_ai_writing_graph()
-snap = await graph.aget_state({"configurable": {"thread_id": "<session_id>"}})
-print(snap.values, snap.next, snap.tasks)
-```
-
-### 直接读 sqlite checkpointer
-
-```bash
-sqlite3 /app/.deer-flow/data/checkpoints.db
-.tables                          # 看表（checkpoints / checkpoint_writes 等）
-SELECT thread_id, checkpoint_ns, checkpoint_id FROM checkpoints 
-  WHERE thread_id = '<session_id>' LIMIT 5;
-```
-
-### 查 MySQL 业务行
-
-```sql
-SELECT id, status, draft_title, updated_at,
-       JSON_LENGTH(transcript) AS transcript_size
-  FROM ai_writing_sessions
-  WHERE id = '<session_id>';
-```
-
-### 查内存中的活跃会话（调试时手动加）
-
-```python
-# 临时在路由加一个 admin 接口
-@router.get("/admin/inflight")
-async def admin_inflight():
-    return {
-        "event_queues": list(_event_queues.keys()),
-        "inflight_tasks": len(_inflight_graph_tasks),
-        "pending_pause": list(_session_pending_pause.keys()),
-    }
-```
-
-### 日志关键字
-
-```bash
-docker logs <gateway> 2>&1 | grep -E 'ai_writing|AsyncSqliteSaver|checkpointer|recovered'
-```
-
-期望看到（启动时）：
-- `ai_writing: 使用 AsyncSqliteSaver (xxx.db)` — 持久化生效
-- `ai_writing_cleanup: 已启动 cron=...` — 清理调度起来
-
-警告：
-- `ai_writing: 持久化 checkpointer 不可用，退回 InMemorySaver` — sqlite 故障
-- `⚠ 检测到 WEB_CONCURRENCY=N` — 多 worker 警告（详见 `ai-writing-说明.md`）
-
----
-
-## 十六、性能与限制
-
-### 单 session 资源占用
-- 内存：~50KB（state + progress_events 累计）
-- sqlite checkpoint：每次 state update 写一行（一篇完整文章约 20-50 行）
-- LLM tokens：约 30K-100K（取决于素材量 + 字数 + 修订次数）
-
-### 并发上限
-- 单 worker 内：理论上百级 session 并发（IO bound），实际 LLM API rate limit 才是瓶颈
-- 多 worker：**当前 in-memory dict 隔离，详见 ai-writing-说明.md 第六章**
-
-### 长会话风险
-- progress_events 累加无界 → 长会话 state 可能膨胀到几 MB
-- transcript JSON 同理 → MySQL 行可能上 MB（但 LONGTEXT 列上限 4GB，影响读取性能）
-
-### 优化方向
-- progress_events 节流（聚合 chunk 事件）
-- transcript 增量保存（diff 而非全量覆盖）
-- 节点级 LLM 调用加 retry（tenacity）
-
----
-
-## 十七、与主 Agent 的关系
-
-| 维度 | 主 Agent | AI 写作 |
-|---|---|---|
-| Graph 入口 | `make_lead_agent` | `AI_WRITING_GRAPH` |
-| Middleware | 18 层中间件 | 无（直接节点链） |
-| State | `ThreadState` | `AIWritingState` |
-| Checkpointer | `make_checkpointer()`（共享） | `_get_async_checkpointer()`（同一文件，不同 thread_id 命名空间） |
-| 路由前缀 | `/api/langgraph/*` `/api/threads/*` | `/api/ai-writing/*` |
-| 流式协议 | LangGraph stream_mode（messages-tuple/values） | 自定义 SSE 事件 |
-| 用户干预 | 通过 `ask_clarification` 工具 | 通过 LangGraph `interrupt()` |
-| 持久化业务表 | `threads_meta`、`runs` | `ai_writing_sessions` |
-
-二者**完全独立**，仅在「共享同一个 sqlite checkpointer 文件」这一点上有间接关联（也可以拆开，性能层面没区别）。
-
----
-
-## 十八、未来 RFC 方向
-
-| 主题 | 描述 |
-|---|---|
-| 多 worker 部署支持 | 把 `_event_queues` 等搬 Redis Pub/Sub，参考 `ai-writing-说明.md` 方案 B |
-| Graph 拓扑可配置 | 现在节点链路写死，未来按 article_type 走不同拓扑（如「研报」vs「散文」） |
-| 节点级重试 | LLM 抽风时自动重试 N 次，参考 `tenacity` |
-| 素材跨 session 复用 | 同一用户多次写作可能用同一批素材 → 缓存层 |
-| 多模态素材 | 支持图片素材输入和图文混合输出 |
-| 中文标点 / 排版规则注入 | 在节点 prompt 里强化中文出版规范 |
-
----
-
-## 附录 A：相关文件速查
-
-| 文件 | 行数 | 用途 |
-|---|---|---|
-| `routers/ai_writing.py` | 1006 | 路由 + 状态字典 + SSE + drain |
-| `agents/ai_writing/graph.py` | 538 | StateGraph + checkpointer 工厂 |
-| `agents/ai_writing/state.py` | 121 | AIWritingState 定义 |
-| `agents/ai_writing/nodes/_utils.py` | 242 | LLM 工具 |
-| `agents/ai_writing/nodes/intent_parser.py` | 131 | 节点：意图解析 |
-| `agents/ai_writing/nodes/researcher.py` | 271 | 节点：素材检索 |
-| `agents/ai_writing/nodes/writer_outline.py` | 147 | 节点：大纲规划 |
-| `agents/ai_writing/nodes/writer_draft.py` | 318 | 节点：草稿生成 |
-| `agents/ai_writing/nodes/editor.py` | 180 | 节点：编辑审核 |
-| `app/gateway/ai_writing_cleanup.py` | ~280 | 清理 + 调度 |
-| `persistence/ai_writing_sessions/sql.py` | ~200 | Repository |
-| `persistence/ai_writing_sessions/model.py` | ~35 | ORM |
-
----
-
-## 附录 B：常见踩坑
-
-| 现象 | 根因 | 解决 |
-|---|---|---|
-| `/start` 报 500 | graph 编译失败（多半是 import 错） | 看启动日志 stack trace |
-| `/resume` 报 404 | session_id 不存在或 checkpointer 没快照 | 看 `ai_writing recover` 日志 |
-| transcript 500 | DB 列容量 / 网络抖 | ✅ 已修，前端 fire-and-forget |
-| SSE 卡住不动 | 多 worker SSE 隔离 / 反代超时 | 见 `ai-writing-说明.md` |
-| `draft_chunk` 丢失内容 | `ThinkTagParser` 在 `<think>` 标签边界处理 | 看 `_utils.py:ThinkTagParser.feed` 单测 |
-| graph 卡在某节点不退出 | LLM API 卡住 / 无限重试 | 看节点日志，加 timeout |
-| cleanup 没跑 | cron 表达式配错 / 文件锁被其他 worker 持有 | 看 `ai_writing_cleanup` 日志 |
-| 草稿在前端看不到但 MySQL 有 | 多 worker 导致 SSE 事件丢失 | 同上 |
-| 配 mysql 做 checkpointer 报错 | LangGraph 不支持 MySQL checkpointer | 用 sqlite 或 postgres |
-
----
-
-如需补充内容，请直接编辑本文件，并在 git commit message 里注明改动原因。

frontend-web/docs/ai-writing-assistant-backend-api.md

@@ -1,726 +0,0 @@
-# AI 写作助手后端接口与 Prompt 协议文档
-
-## 1. 文档目标
-
-本文档用于指导 AI 写作助手第二阶段升级中的后端开发、接口设计、提示词设计和联调约束。
-
-本轮后端目标不是重做 DeerFlow 的整体架构，而是在保留现有 Python + LangGraph + 线程体系的基础上，新增一套稳定的“选区改写型能力”，服务前端的 Tiptap 写作编辑器。
-
----
-
-## 2. 本轮后端职责
-
-后端负责：
-
-- 接收当前线程信息
-- 接收用户选区文本
-- 接收改写动作
-- 选取必要上下文
-- 调用模型生成候选改写结果
-- 返回纯净候选文本
-
-后端本轮不负责：
-
-- 直接编辑 Tiptap JSON
-- 直接操作前端编辑器选区
-- 直接替换前端文档内容
-- 做复杂富文本 patch
-- 做 tracked changes
-
----
-
-## 3. 设计原则
-
-### 3.1 纯文本协议优先
-
-首版只让后端处理：
-
-- 选区文本
-- 前后文文本
-- 动作类型
-- 风格参数
-
-不让后端直接理解完整富文本 JSON。
-
-### 3.2 前端负责应用，后端负责生成
-
-- 前端负责选区获取
-- 前端负责候选结果展示
-- 前端负责替换 / 插入
-- 后端只负责“给出候选文本”
-
-### 3.3 结果必须可直接落文档
-
-后端输出必须尽量是可直接放回编辑器的正文，不应带解释性前缀，例如：
-
-- “当然可以，以下是润色版本：”
-- “我帮你改写如下：”
-- “下面是优化后的内容：”
-
-这类内容必须禁止。
-
----
-
-## 4. 推荐接口设计
-
-## 4.1 主接口
-
-推荐新增统一接口：
-
-```text
-POST /api/writing/rewrite
-```
-
-由 `action` 决定具体重写类型。
-
-## 4.2 为什么推荐统一接口
-
-因为前端交互是一套统一浮层和统一预览面板，拆成多个接口会导致：
-
-- 前端判断分支增多
-- 埋点与异常处理分散
-- 后续新增动作不方便扩展
-
-统一接口更适合本轮需求。
-
----
-
-## 5. 请求体定义
-
-建议请求体如下：
-
-```json
-{
-  "threadId": "string",
-  "documentId": "string",
-  "selection": {
-    "from": 120,
-    "to": 260,
-    "text": "待改写文本"
-  },
-  "action": "polish",
-  "tone": "professional",
-  "surroundingContext": {
-    "before": "选区前文",
-    "after": "选区后文"
-  }
-}
-```
-
----
-
-## 6. 字段说明
-
-### 6.1 `threadId`
-
-用途：
-
-- 关联当前 DeerFlow 线程
-- 必要时取线程上下文或会话元数据
-
-### 6.2 `documentId`
-
-用途：
-
-- 标识当前右侧文档
-- 首版可选
-- 如果当前系统还没有独立文档 ID，可先允许为空
-
-### 6.3 `selection.from` / `selection.to`
-
-用途：
-
-- 帮助前后端联调排查
-- 首版后端通常不需要真正使用偏移量
-- 建议保留，便于日志定位
-
-### 6.4 `selection.text`
-
-用途：
-
-- 这是本轮最核心输入
-- 后端实际重写的主文本
-
-### 6.5 `action`
-
-允许值：
-
-- `polish`
-- `expand`
-- `shorten`
-- `tone`
-
-### 6.6 `tone`
-
-仅当 `action = tone` 时使用。
-
-建议允许值：
-
-- `professional`
-- `casual`
-- `readable`
-- `academic`
-- `expressive`
-
-### 6.7 `surroundingContext.before`
-
-用途：
-
-- 提供选区前文
-- 帮助模型理解语气、主语、叙事连续性
-
-建议：
-
-- 控制长度
-- 不要塞太多无关上下文
-
-### 6.8 `surroundingContext.after`
-
-用途：
-
-- 提供选区后文
-- 帮助模型在扩写、改语气时与后续内容衔接
-
----
-
-## 7. 返回体定义
-
-建议返回体如下：
-
-```json
-{
-  "output": "AI 改写后的候选文本",
-  "originalSelection": {
-    "from": 120,
-    "to": 260,
-    "text": "待改写文本"
-  },
-  "metadata": {
-    "action": "polish",
-    "tone": null,
-    "model": "your-model-name"
-  }
-}
-```
-
----
-
-## 8. 返回字段要求
-
-## 8.1 `output`
-
-必须：
-
-- 只包含候选正文
-- 尽量不夹带解释语
-- 能直接被前端替换或插入
-
-## 8.2 `originalSelection`
-
-作用：
-
-- 前端可以做校验
-- 联调时方便确认是针对哪段文本返回的
-
-## 8.3 `metadata`
-
-作用：
-
-- 便于埋点
-- 便于日志记录
-- 便于问题追踪
-
----
-
-## 9. 错误响应规范
-
-建议统一错误结构：
-
-```json
-{
-  "error": {
-    "code": "WRITING_REWRITE_FAILED",
-    "message": "rewrite failed"
-  }
-}
-```
-
-建议错误码：
-
-- `WRITING_REWRITE_FAILED`
-- `WRITING_INVALID_ACTION`
-- `WRITING_INVALID_TONE`
-- `WRITING_EMPTY_SELECTION`
-- `WRITING_MODEL_UNAVAILABLE`
-- `WRITING_CONTEXT_TOO_LARGE`
-
----
-
-## 10. 动作语义定义
-
-## 10.1 `polish`
-
-目标：
-
-- 保持原意
-- 改善表达
-- 提升通顺度、自然度和可读性
-
-不应：
-
-- 引入新事实
-- 改写成完全不同内容
-
-## 10.2 `expand`
-
-目标：
-
-- 保持主旨
-- 扩充细节
-- 增强画面感、解释性或完整度
-
-不应：
-
-- 无限制发散
-- 添加明显脱离主题的新内容
-
-## 10.3 `shorten`
-
-目标：
-
-- 压缩篇幅
-- 保留关键信息
-- 减少重复表达
-
-不应：
-
-- 丢失关键论点
-- 压缩到语义残缺
-
-## 10.4 `tone`
-
-目标：
-
-- 不改变原意
-- 调整语言风格
-
-不应：
-
-- 改写事实
-- 改写逻辑结构到完全不同
-
----
-
-## 11. Prompt 设计原则
-
-## 11.1 通用系统约束
-
-所有改写类 prompt 都应包含以下约束：
-
-- 直接输出最终可用正文
-- 不输出标题，除非原文本身就是标题改写
-- 不输出解释
-- 不输出分析过程
-- 不输出“以下是结果”之类前缀
-- 保持与上下文语气一致
-
-## 11.2 上下文使用原则
-
-前后文只用于理解，不要求模型重写前后文。
-
-明确告诉模型：
-
-- 只改写选中文本
-- 前后文仅用于参考衔接
-
-## 11.3 长度控制原则
-
-- `polish`：长度与原文接近
-- `expand`：长度可明显增加，但不要失控
-- `shorten`：长度明显缩短，但要保留关键信息
-- `tone`：长度尽量与原文接近
-
----
-
-## 12. Prompt 模板建议
-
-## 12.1 润色模板
-
-```text
-你是一名中文写作编辑助手。
-
-请在不改变原意的前提下，对“选中文本”进行润色，使表达更自然、更流畅、更清晰。
-
-要求：
-1. 保留原文事实和核心意思。
-2. 不要添加原文没有的新事实。
-3. 不要输出解释，不要输出前缀，不要输出分析过程。
-4. 直接输出润色后的正文。
-
-前文参考：
-{before}
-
-选中文本：
-{selection}
-
-后文参考：
-{after}
-```
-
-## 12.2 扩写模板
-
-```text
-你是一名中文写作编辑助手。
-
-请在不偏离主题的前提下，对“选中文本”进行扩写，增加必要细节、画面感或补充说明，使内容更充实。
-
-要求：
-1. 保持原文主旨不变。
-2. 增加内容时要自然，不要跑题。
-3. 不要输出解释，不要输出前缀，不要输出分析过程。
-4. 直接输出扩写后的正文。
-
-前文参考：
-{before}
-
-选中文本：
-{selection}
-
-后文参考：
-{after}
-```
-
-## 12.3 缩写模板
-
-```text
-你是一名中文写作编辑助手。
-
-请在保留关键信息和原意的前提下，对“选中文本”进行缩写，使其更精炼。
-
-要求：
-1. 不要丢掉核心信息。
-2. 去掉重复、冗余和拖沓表达。
-3. 不要输出解释，不要输出前缀，不要输出分析过程。
-4. 直接输出缩写后的正文。
-
-前文参考：
-{before}
-
-选中文本：
-{selection}
-
-后文参考：
-{after}
-```
-
-## 12.4 改语气模板
-
-```text
-你是一名中文写作编辑助手。
-
-请在不改变原意和事实的前提下，把“选中文本”改写成更{tone_label}的表达方式。
-
-要求：
-1. 保持原文信息不变。
-2. 只调整表达风格，不改变事实和逻辑。
-3. 不要输出解释，不要输出前缀，不要输出分析过程。
-4. 直接输出改写后的正文。
-
-前文参考：
-{before}
-
-选中文本：
-{selection}
-
-后文参考：
-{after}
-```
-
----
-
-## 13. Tone 映射建议
-
-建议前端传标准值，后端映射中文标签：
-
-- `professional` -> 专业、正式
-- `casual` -> 口语化、轻松自然
-- `readable` -> 更易读、更清晰
-- `academic` -> 学术、严谨
-- `expressive` -> 更有文采、更有表现力
-
----
-
-## 14. 上下文截取策略
-
-## 14.1 推荐策略
-
-前端传：
-
-- 选区前固定长度文本
-- 选区后固定长度文本
-
-例如：
-
-- 前文 200 到 500 字
-- 后文 200 到 500 字
-
-### 原因
-
-- 足够帮助模型理解文气和衔接
-- 不会让请求太重
-
-## 14.2 不建议
-
-- 把整篇长文全量塞进去
-- 把整个线程消息都塞进改写接口
-
-如果后端确实要参考线程上下文，也建议只取最近和写作相关的少量消息摘要。
-
----
-
-## 15. LangGraph 接入建议
-
-## 15.1 推荐接入方式
-
-在现有 LangGraph / gateway 架构中新增一个写作改写专用入口。
-
-建议二选一：
-
-### 方案 A
-
-新增专用 router：
-
-- `POST /api/writing/rewrite`
-
-内部调用现有模型层 / agent 层。
-
-### 方案 B
-
-新增专用 graph node 或 tool：
-
-- `rewrite_selection`
-
-再由 router 调用该能力。
-
-## 15.2 更推荐方案
-
-推荐：
-
-- 对外暴露统一 router
-- 内部走已有模型封装或 LangGraph 节点
-
-这样前端接口更稳定，后续后端内部重构不会影响前端。
-
----
-
-## 16. 后端模块拆解
-
-## 16.1 模块 A：接口层
-
-负责：
-
-- 请求校验
-- 错误响应
-- 参数标准化
-
-需要完成：
-
-- 统一 rewrite API
-- action / tone 校验
-- 空选区校验
-
-## 16.2 模块 B：上下文拼装层
-
-负责：
-
-- 拼装 before / selection / after
-- 必要时提取线程相关信息
-
-需要完成：
-
-- 上下文长度控制
-- 清洗空白和异常字符
-
-## 16.3 模块 C：Prompt 层
-
-负责：
-
-- 选择模板
-- 填充 action 和 tone
-
-需要完成：
-
-- 4 类动作模板
-- tone 映射
-
-## 16.4 模块 D：模型调用层
-
-负责：
-
-- 走现有模型配置体系
-- 执行大模型请求
-
-需要完成：
-
-- 统一调用入口
-- 模型不可用错误处理
-
-## 16.5 模块 E：结果清洗层
-
-负责：
-
-- 去掉解释性前缀
-- 去掉多余包裹
-- 标准化返回
-
-需要完成：
-
-- 输出清洗
-- metadata 填充
-
----
-
-## 17. 返回结果清洗建议
-
-即使 prompt 已经约束，模型仍可能输出：
-
-- “以下是润色后的内容：”
-- “当然，这里是改写结果：”
-- “优化如下：”
-
-建议后端加一层轻量清洗：
-
-- 去掉常见说明性前缀
-- 去掉包裹性 markdown 代码块
-- 去掉多余首尾空白
-
-注意：
-
-- 清洗必须保守
-- 不要误删正文
-
----
-
-## 18. 日志与观测建议
-
-建议记录：
-
-- `threadId`
-- `documentId`
-- `action`
-- `tone`
-- `selection_length`
-- `before_length`
-- `after_length`
-- `model_name`
-- `latency_ms`
-- `success / fail`
-
-不要直接把整段用户正文原文打到普通日志里，避免敏感信息风险。
-
----
-
-## 19. 后端测试清单
-
-## 19.1 单元测试
-
-- action 校验
-- tone 校验
-- 空选区校验
-- prompt 选择逻辑
-- 输出清洗逻辑
-
-## 19.2 集成测试
-
-- `polish`
-- `expand`
-- `shorten`
-- `tone-professional`
-- `tone-casual`
-- `tone-readable`
-- `tone-academic`
-- `tone-expressive`
-
-## 19.3 边界测试
-
-- 选区过短
-- 选区过长
-- 前后文为空
-- 多段文本带换行
-- 模型超时
-- 模型不可用
-
----
-
-## 20. 联调约束
-
-## 20.1 前后端必须统一
-
-- `action` 枚举值
-- `tone` 枚举值
-- 错误码
-- 返回体字段名
-
-## 20.2 联调重点
-
-- 多段落文本中换行保留是否正确
-- AI 返回内容是否适合直接落文档
-- 超时和失败时前端是否能优雅重试
-
-## 20.3 联调建议顺序
-
-1. 先 mock 返回固定文本
-2. 再接真实模型
-3. 先验证单段落
-4. 再验证多段落
-5. 最后验证大段文本
-
----
-
-## 21. 优先级建议
-
-### P0
-
-- 统一 rewrite API
-- 4 类动作支持
-- 输出纯净正文
-- 错误结构标准化
-
-### P1
-
-- 输出清洗增强
-- 埋点与日志
-- 上下文截断策略优化
-
-### P2
-
-- 更细粒度风格控制
-- 结果质量二次校验
-
----
-
-## 22. 完成定义
-
-后端满足以下条件即可视为本轮完成：
-
-- 前端能通过统一接口发起改写
-- 4 类动作均可稳定返回候选文本
-- 返回文本基本可直接用于替换或插入
-- 多段落文本能稳定处理
-- 错误结构规范统一
-
----
-
-## 23. 结论
-
-本轮后端最重要的，不是做复杂文档结构编辑，而是把“选区改写”做成稳定、可预测、可直接接入前端编辑器的能力。
-
-最稳妥的路线是：
-
-- 统一接口
-- 统一动作枚举
-- 统一 prompt 模板
-- 统一错误结构
-- 统一输出约束
-
-只要这层做稳，前端的 Tiptap 写作编辑器就能很顺畅地完成豆包式“选中即改、预览后应用”的核心体验。 

frontend-web/docs/ai-writing-assistant-frontend-checklist.md

@@ -1,703 +0,0 @@
-# AI 写作助手前端开发任务清单
-
-## 1. 文档目标
-
-本文档用于把《AI 写作助手右侧编辑器升级需求文档》进一步拆成前端可直接执行的任务清单。
-
-目标是让前端团队按模块并行推进，最终完成：
-
-- 保留左侧聊天区
-- 右侧升级为 `Tiptap` 写作编辑器
-- 支持选区浮层
-- 支持润色 / 扩写 / 缩写 / 改语气
-- 支持替换 / 插入
-- 支持标题 / 列表 / 引用 / 代码块工具条
-- UI 参考豆包 + Novel + open-canvas
-
----
-
-## 2. 本轮前端改造范围
-
-### 2.1 保留不动
-
-- 左侧聊天主链路
-- 现有线程消息流
-- 现有模型选择器
-- 现有输入框的 `writing_mode` 总入口
-
-### 2.2 重点改造
-
-- 右侧 Artifact 面板承载方式
-- 新增独立写作工作区
-- 富文本编辑器内核
-- 选区浮层
-- AI 改写结果预览
-- 文档级工具条
-
----
-
-## 3. 推荐目录结构
-
-建议新增独立模块目录：
-
-```text
-frontend-web/src/open-canvas-writing/
-  routes/
-    WritingRoutes.tsx
-  pages/
-    WritingWorkspacePage.tsx
-  components/
-    WritingShell.tsx
-    WritingHeader.tsx
-    WritingToolbar.tsx
-    WritingEditorPane.tsx
-    WritingBubbleMenu.tsx
-    WritingAiMenu.tsx
-    WritingRewritePreview.tsx
-    WritingStatusBar.tsx
-    WritingEmptyState.tsx
-  editor/
-    TiptapEditor.tsx
-    TiptapExtensions.ts
-    commands.ts
-    selection.ts
-  context/
-    WritingEditorContext.tsx
-  hooks/
-    useWritingEditor.ts
-    useWritingSelection.ts
-    useWritingRewrite.ts
-    useWritingToolbar.ts
-  api/
-    rewrite.ts
-    documents.ts
-  types/
-    document.ts
-    rewrite.ts
-  utils/
-    apply-rewrite.ts
-    markdown.ts
-    editor-style.ts
-```
-
----
-
-## 4. 现有代码落点
-
-## 4.1 需要接入的现有文件
-
-- `frontend-web/src/pages/PageRoutes.tsx`
-  - 增加新写作路由入口
-
-- `frontend-web/src/components/workspace/chats/chat-box.tsx`
-  - 当前双栏布局参考来源
-  - 后续决定是否复用布局容器，或在新页面中重建双栏
-
-- `frontend-web/src/components/workspace/input-box.tsx`
-  - 保留 `writing_mode`
-  - 后续可在切换写作模式时跳转到新写作页面
-
-- `frontend-web/src/components/workspace/artifacts/context.tsx`
-  - 仅保留给旧 Artifact 逻辑
-  - 不要继续承载写作编辑器状态
-
-## 4.2 不建议继续沿用的方式
-
-- 不要把编辑器主状态存成 `string[] artifacts`
-- 不要把右侧主体验继续建在 `artifact-file-detail.tsx` 上
-- 不要让 AI 改写结果先回聊天，再由用户手动复制
-
----
-
-## 5. 任务分阶段拆解
-
-## 阶段 A：路由与页面壳
-
-### 目标
-
-先把新的写作工作区页面立起来，让后续编辑器与交互都有落点。
-
-### 任务
-
-- 新增 `WritingRoutes.tsx`
-- 新增 `WritingWorkspacePage.tsx`
-- 在 `PageRoutes.tsx` 中挂入 `page/writing/*`
-- 确认新页面进入方式
-- 确定是：
-  - 通过左侧聊天上下文进入
-  - 通过 `writing_mode` 入口进入
-  - 或二者都支持
-
-### 交付物
-
-- 新写作页面能被路由访问
-- 页面有基础左右布局和空态
-
-### 验收
-
-- 打开 `page/writing` 能进入工作区
-- 页面不报错
-
----
-
-## 阶段 B：编辑器底座
-
-### 目标
-
-把右侧正式替换成富文本编辑器。
-
-### 任务
-
-- 安装 Tiptap 依赖
-- 建立 `TiptapEditor.tsx`
-- 建立 `TiptapExtensions.ts`
-- 配置节点：
-  - paragraph
-  - heading
-  - bulletList
-  - orderedList
-  - listItem
-  - blockquote
-  - codeBlock
-  - hardBreak
-- 配置 marks：
-  - bold
-  - italic
-  - underline
-  - strike
-  - code
-- 建立编辑器初始化逻辑
-- 建立编辑器销毁逻辑
-- 定义最小文档状态
-
-### 交付物
-
-- 可编辑正文区域
-- 初始文档可加载
-- 内容可读可写
-
-### 验收
-
-- 可以直接输入正文
-- 可以换行、加标题、切换列表
-- 不出现内容错位和明显闪烁
-
----
-
-## 阶段 C：主工具栏
-
-### 目标
-
-右侧具备正式写作工具栏。
-
-### 任务
-
-- 新增 `WritingToolbar.tsx`
-- 新增 `useWritingToolbar.ts`
-- 实现按钮：
-  - 正文
-  - H1
-  - H2
-  - H3
-  - 有序列表
-  - 无序列表
-  - 引用
-  - 代码块
-  - 加粗
-  - 斜体
-  - 下划线
-  - 删除线
-- 处理 active 状态
-- 处理不可用状态
-- 处理光标块状态联动
-
-### 交付物
-
-- 主工具栏可用
-
-### 验收
-
-- 工具条按钮能正确反映当前块状态
-- 操作后编辑器内容正确变化
-
----
-
-## 阶段 D：选区状态与浮层
-
-### 目标
-
-实现豆包式选区浮层基础能力。
-
-### 任务
-
-- 新增 `useWritingSelection.ts`
-- 新增 `selection.ts`
-- 新增 `WritingBubbleMenu.tsx`
-- 基于 Tiptap 监听 selection 变化
-- 过滤掉空选区
-- 处理多段连续选区
-- 浮层按钮：
-  - AI 改写
-  - 加粗
-  - 斜体
-  - 标题
-  - 复制
-- 处理滚动定位
-- 处理窗口尺寸变化
-
-### 交付物
-
-- 选中内容后出现浮层
-
-### 验收
-
-- 单段可触发
-- 多段可触发
-- 浮层位置稳定
-
----
-
-## 阶段 E：AI 改写菜单
-
-### 目标
-
-把选区浮层接到 AI 改写工作流。
-
-### 任务
-
-- 新增 `WritingAiMenu.tsx`
-- 新增 `useWritingRewrite.ts`
-- 新增 `api/rewrite.ts`
-- 实现一级动作：
-  - 润色
-  - 扩写
-  - 缩写
-  - 改语气
-- 实现改语气二级菜单：
-  - 更专业
-  - 更口语化
-  - 更易读
-  - 更学术
-  - 更有文采
-- 封装请求入参
-- 增加 loading 态
-- 增加 error 态
-- 增加 retry 入口
-
-### 交付物
-
-- AI 改写菜单和请求链路
-
-### 验收
-
-- 4 个动作都能发请求
-- 改语气的二级菜单可正常展开
-- 请求失败时有反馈
-
----
-
-## 阶段 F：候选结果预览
-
-### 目标
-
-把 AI 结果变成“可预览、可决策、可回退”的候选内容。
-
-### 任务
-
-- 新增 `WritingRewritePreview.tsx`
-- 新增 `apply-rewrite.ts`
-- 显示原文与候选内容
-- 提供按钮：
-  - 替换
-  - 插入
-  - 重试
-  - 取消
-- 用 transaction 应用结果
-- 处理应用成功后的焦点与滚动
-
-### 交付物
-
-- 改写结果预览卡片或面板
-
-### 验收
-
-- 替换准确
-- 插入准确
-- 取消后文档保持原样
-
----
-
-## 阶段 G：文档状态与容器体验
-
-### 目标
-
-补齐正式产品的壳层体验。
-
-### 任务
-
-- 新增 `WritingShell.tsx`
-- 新增 `WritingHeader.tsx`
-- 新增 `WritingStatusBar.tsx`
-- 新增 `WritingEmptyState.tsx`
-- 补充文档标题区域
-- 补充文档状态提示
-- 补充空态和加载态
-
-### 交付物
-
-- 页面完整壳层
-
-### 验收
-
-- 页面不是裸编辑器
-- 有完整的文档工作区感
-
----
-
-## 阶段 H：视觉打磨
-
-### 目标
-
-让整体观感接近成熟产品。
-
-### 任务
-
-- 调整右侧阅读宽度
-- 调整字体大小和行高
-- 调整段距和标题层级
-- 调整工具栏阴影、边框、圆角
-- 调整浮层动效
-- 调整 AI 预览卡片质感
-- 优化深浅色模式兼容
-
-### 交付物
-
-- 完整视觉优化
-
-### 验收
-
-- 明显优于当前版本
-- 有豆包 / Novel 风格的编辑器质感
-
----
-
-## 6. 组件级开发清单
-
-## 6.1 `WritingWorkspacePage.tsx`
-
-职责：
-
-- 页面级容器
-- 获取线程 / 文档上下文
-- 组织左右布局
-
-必须完成：
-
-- 页面初始化
-- 与左侧聊天协同
-- 右侧编辑区挂载
-
-## 6.2 `WritingShell.tsx`
-
-职责：
-
-- 写作工作区总壳层
-- 布局标题区、工具栏、正文区、状态区
-
-必须完成：
-
-- 自适应布局
-- 桌面端优先
-- 窄屏降级
-
-## 6.3 `TiptapEditor.tsx`
-
-职责：
-
-- 包装 Tiptap EditorContent
-- 负责 editor 实例初始化
-
-必须完成：
-
-- `onUpdate`
-- `onSelectionUpdate`
-- 内容同步
-
-## 6.4 `WritingToolbar.tsx`
-
-职责：
-
-- 顶部主工具栏
-
-必须完成：
-
-- 所有基础格式化命令
-- 当前状态高亮
-
-## 6.5 `WritingBubbleMenu.tsx`
-
-职责：
-
-- 选区浮层
-
-必须完成：
-
-- 跟随选区
-- 基础快捷操作
-- AI 改写入口
-
-## 6.6 `WritingAiMenu.tsx`
-
-职责：
-
-- AI 改写动作菜单
-
-必须完成：
-
-- 一级菜单
-- 改语气二级菜单
-- 动作触发
-
-## 6.7 `WritingRewritePreview.tsx`
-
-职责：
-
-- 展示候选内容
-
-必须完成：
-
-- 替换
-- 插入
-- 重试
-- 取消
-
----
-
-## 7. Hook 级开发清单
-
-## 7.1 `useWritingEditor.ts`
-
-负责：
-
-- editor 生命周期
-- 初始内容装载
-- 内容变更同步
-
-## 7.2 `useWritingSelection.ts`
-
-负责：
-
-- 当前选区抽取
-- 选区文本缓存
-- 多段落纯文本拼接
-
-## 7.3 `useWritingRewrite.ts`
-
-负责：
-
-- 改写请求
-- loading / success / error
-- 结果缓存
-- 重试
-
-## 7.4 `useWritingToolbar.ts`
-
-负责：
-
-- toolbar active 状态
-- editor command 映射
-
----
-
-## 8. API 对接清单
-
-前端需向后端约定以下接口能力：
-
-- `POST /api/writing/rewrite`
-
-前端请求内容至少包括：
-
-- `threadId`
-- `documentId`
-- `selection.from`
-- `selection.to`
-- `selection.text`
-- `action`
-- `tone`
-- `surroundingContext.before`
-- `surroundingContext.after`
-
-前端需处理的返回字段：
-
-- `output`
-- `originalSelection`
-- `metadata`
-
----
-
-## 9. 状态管理建议
-
-建议新增独立 Context：
-
-- `WritingEditorContext.tsx`
-
-建议持有：
-
-- 当前文档内容
-- 当前 editor 实例
-- 当前选区
-- 当前改写请求状态
-- 当前候选结果
-- 当前 UI 面板状态
-
-不建议继续复用旧 Artifact Context 的原因：
-
-- 旧 Context 关注文件列表和文件路径
-- 新编辑器关注选区、结构、候选结果、应用动作
-- 关注点完全不同
-
----
-
-## 10. 前端联调检查点
-
-## 10.1 与后端联调前
-
-- 先用 mock 数据打通浮层和预览
-- 先验证替换 / 插入逻辑
-
-## 10.2 与后端联调时
-
-- 检查多段落选区拼接结果
-- 检查 AI 返回内容是否带说明性前缀
-- 检查替换后位置是否准确
-
-## 10.3 联调后
-
-- 验证大段文本性能
-- 验证撤销 / 重做
-- 验证快速连续触发是否会状态错乱
-
----
-
-## 11. 前端测试清单
-
-## 11.1 功能测试
-
-- 输入正文
-- 插入标题
-- 切换列表
-- 插入引用
-- 插入代码块
-- 加粗 / 斜体 / 下划线 / 删除线
-- 选区浮层显示
-- 选区浮层隐藏
-- AI 改写菜单打开
-- 改语气二级菜单打开
-- 改写结果替换
-- 改写结果插入
-- 改写结果取消
-
-## 11.2 场景测试
-
-- 单段短文本润色
-- 多段文本润色
-- 多段文本扩写
-- 多段文本缩写
-- 多段文本改语气
-- 连续两次改写同一段
-- 快速切换线程后重新进入
-
-## 11.3 回归测试
-
-- 左侧聊天是否正常
-- 模型切换是否正常
-- `writing_mode` 是否正常
-- 原有 artifact 模块是否仍可使用
-
----
-
-## 12. 任务优先级
-
-### P0
-
-- 路由与页面壳
-- Tiptap 接入
-- 主工具栏
-- 选区浮层
-- 改写菜单
-- 替换 / 插入
-
-### P1
-
-- 页面头部与状态
-- 优雅 loading / error / retry
-- 多段落稳定性
-- UI 打磨
-
-### P2
-
-- 空态优化
-- 动效优化
-- 快捷键支持
-
----
-
-## 13. 建议分工
-
-### 前端 1 号
-
-负责：
-
-- 路由与页面壳
-- Tiptap 接入
-- 主工具栏
-
-### 前端 2 号
-
-负责：
-
-- 选区状态
-- BubbleMenu
-- AI 菜单
-
-### 前端 3 号
-
-负责：
-
-- 候选结果预览
-- 替换 / 插入
-- 状态栏与页面体验
-
-### 联调负责人
-
-负责：
-
-- 前后端请求协议
-- 错误态规范
-- 多段落测试和回归
-
----
-
-## 14. 前端完成定义
-
-满足以下条件可视为前端完成：
-
-- 右侧能作为正式编辑器独立使用
-- 选区后可直接发起 AI 改写
-- 改写后可替换或插入
-- 视觉上明显优于当前版本
-- 左侧聊天和现有系统不被破坏
-
----
-
-## 15. 下一步建议
-
-前端团队可以按以下顺序开工：
-
-1. 先起页面和路由
-2. 再接 Tiptap 与主工具栏
-3. 再做选区浮层
-4. 再接 AI 菜单和结果预览
-5. 最后做视觉打磨
-
-这个顺序风险最小，也最容易在中途验收。 

frontend-web/docs/ai-writing-assistant-source-map.md

@@ -1,457 +0,0 @@
-# AI 写作助手源码与实现映射表
-
-## 1. 文档目标
-
-本文档用于把以下几类信息对应起来：
-
-- 豆包 AI 写作助手里要借鉴的交互
-- Novel / open-canvas / Tiptap 中可参考的实现思路
-- DeerFlow 当前项目里已经存在的落点
-- 本次新建模块应该落到哪里
-
-这份文档不是源码复制文档，而是开发时的“对照表”和“导航图”。
-
----
-
-## 2. 使用方式
-
-开发时建议按以下顺序看：
-
-1. 先看“目标能力”
-2. 再看“参考来源”
-3. 再看“DeerFlow 当前落点”
-4. 最后看“本次目标文件”
-
-这样可以避免出现两种常见问题：
-
-- 直接照搬外部项目结构，结果和你们现有架构冲突
-- 只看自己项目，不知道成熟产品交互应该怎么落
-
----
-
-## 3. 总体映射
-
-| 目标能力 | 产品参考 | 外部参考实现 | DeerFlow 当前落点 | 本次目标文件 |
-| --- | --- | --- | --- | --- |
-| 写作工作区路由 | open-canvas 独立页面 | open-canvas 路由组织思路 | `frontend-web/src/pages/PageRoutes.tsx` | `frontend-web/src/open-canvas-writing/routes/WritingRoutes.tsx` |
-| 左右双栏工作区 | 豆包写作页 / open-canvas | open-canvas 页面壳思路 | `frontend-web/src/components/workspace/chats/chat-box.tsx` | `frontend-web/src/open-canvas-writing/pages/WritingWorkspacePage.tsx`、`WritingShell.tsx` |
-| 富文本正文编辑 | Novel | Tiptap 官方编辑器模式 | 当前无正式富文本正文编辑器 | `frontend-web/src/open-canvas-writing/editor/TiptapEditor.tsx` |
-| 文档工具栏 | 豆包 / Novel | Tiptap Toolbar 组合思路 | 当前右侧无正式工具栏 | `frontend-web/src/open-canvas-writing/components/WritingToolbar.tsx` |
-| 选区浮层 | 豆包 | Tiptap BubbleMenu | 当前右侧无选区浮层 | `frontend-web/src/open-canvas-writing/components/WritingBubbleMenu.tsx` |
-| AI 改写菜单 | 豆包 | 自定义菜单 + BubbleMenu 挂接 | 当前无 | `frontend-web/src/open-canvas-writing/components/WritingAiMenu.tsx` |
-| 候选结果预览 | 豆包 / open-canvas | open-canvas 候选应用思路 | 当前无 | `frontend-web/src/open-canvas-writing/components/WritingRewritePreview.tsx` |
-| 替换 / 插入 | 豆包 | Tiptap transaction 应用 | 当前无 | `frontend-web/src/open-canvas-writing/utils/apply-rewrite.ts` |
-| 写作模式总入口 | 当前 DeerFlow | 现有 `writing_mode` 开关 | `frontend-web/src/components/workspace/input-box.tsx` | 保留现有入口并接新页面 |
-| 线程与模型协同 | 当前 DeerFlow | 现有线程 / 模型体系 | 现有 `core/threads`、`core/models` | 继续复用，新增 `api/rewrite.ts` |
-
----
-
-## 4. 豆包功能到 DeerFlow 的映射
-
-## 4.1 滑词 / 选区浮层
-
-### 豆包里的体验
-
-- 选中文本后出现轻量浮层
-- 浮层里有：
-  - AI 改写
-  - 文本样式
-  - 复制
-
-### DeerFlow 当前状态
-
-- 右侧还没有正式的选区级工具层
-
-### 本次实现方式
-
-- 使用 Tiptap 的 `BubbleMenu`
-- 再叠加自定义菜单逻辑
-
-### 本次落点
-
-- `frontend-web/src/open-canvas-writing/components/WritingBubbleMenu.tsx`
-- `frontend-web/src/open-canvas-writing/hooks/useWritingSelection.ts`
-- `frontend-web/src/open-canvas-writing/editor/selection.ts`
-
----
-
-## 4.2 多段落改写
-
-### 豆包里的体验
-
-- 不是只改单句
-- 能对连续几段一起润色、扩写、缩写、改语气
-
-### DeerFlow 当前状态
-
-- 现有右侧编辑区没有正式的多段落选区改写模型
-
-### 本次实现方式
-
-- 前端提取连续选区纯文本
-- 前端附带前后文
-- 后端返回候选纯文本
-- 前端决定替换或插入
-
-### 本次落点
-
-- `frontend-web/src/open-canvas-writing/hooks/useWritingSelection.ts`
-- `frontend-web/src/open-canvas-writing/hooks/useWritingRewrite.ts`
-- `frontend-web/src/open-canvas-writing/api/rewrite.ts`
-
----
-
-## 4.3 替换 / 插入
-
-### 豆包里的体验
-
-- 改写结果不是直接覆盖原文
-- 用户可选择：
-  - 替换
-  - 插入
-
-### DeerFlow 当前状态
-
-- 当前没有候选文本应用层
-
-### 本次实现方式
-
-- 建立候选结果预览区
-- 基于 Tiptap transaction 应用文本
-
-### 本次落点
-
-- `frontend-web/src/open-canvas-writing/components/WritingRewritePreview.tsx`
-- `frontend-web/src/open-canvas-writing/utils/apply-rewrite.ts`
-
----
-
-## 4.4 标题 / 列表 / 引用 / 代码块工具条
-
-### 豆包里的体验
-
-- 右侧本身就是正式文档编辑器
-- 可以快速切换文档结构
-
-### DeerFlow 当前状态
-
-- 当前右侧偏预览，不是正式写作编辑器
-
-### 本次实现方式
-
-- 使用 Tiptap 节点和命令
-- 在主工具栏中集中承载
-
-### 本次落点
-
-- `frontend-web/src/open-canvas-writing/components/WritingToolbar.tsx`
-- `frontend-web/src/open-canvas-writing/hooks/useWritingToolbar.ts`
-- `frontend-web/src/open-canvas-writing/editor/commands.ts`
-- `frontend-web/src/open-canvas-writing/editor/TiptapExtensions.ts`
-
----
-
-## 5. Novel 参考映射
-
-## 5.1 最值得借鉴的不是“代码整搬”，而是这三件事
-
-- 编辑器主容器的产品感
-- 工具栏和空态的组织方式
-- 正文阅读宽度、排版、留白
-
-## 5.2 对应到 DeerFlow 的实现位置
-
-- 页面壳：`WritingShell.tsx`
-- 顶部文档区：`WritingHeader.tsx`
-- 编辑容器：`TiptapEditor.tsx`
-- 工具栏：`WritingToolbar.tsx`
-- 空态：`WritingEmptyState.tsx`
-
-## 5.3 不建议直接照搬的部分
-
-- Next.js 页面结构
-- 依赖其服务端 AI 调用方式
-- 与 Vercel AI SDK 深绑定的部分
-
----
-
-## 6. open-canvas 参考映射
-
-## 6.1 主要借鉴对象
-
-open-canvas 这次最值得借鉴的不是页面外观，而是：
-
-- AI 工作流组织方式
-- 改写结果应用节奏
-- 编辑器和聊天协作的模式
-
-## 6.2 借鉴重点
-
-### 借鉴 1：独立工作区思想
-
-不要把写作体验塞进一个零散的弹窗或文件详情页，要有独立工作区。
-
-对应 DeerFlow：
-
-- `frontend-web/src/open-canvas-writing/pages/WritingWorkspacePage.tsx`
-
-### 借鉴 2：画布状态独立维护
-
-不要让写作状态完全依附聊天消息渲染结果，要独立维护文档和候选状态。
-
-对应 DeerFlow：
-
-- `frontend-web/src/open-canvas-writing/context/WritingEditorContext.tsx`
-
-### 借鉴 3：AI 输出先预览，再应用
-
-对应 DeerFlow：
-
-- `frontend-web/src/open-canvas-writing/components/WritingRewritePreview.tsx`
-
----
-
-## 7. Tiptap 参考映射
-
-## 7.1 Tiptap 在本项目中的职责
-
-- 作为右侧正式富文本编辑器内核
-- 提供结构节点与 marks
-- 提供 BubbleMenu 能力
-- 提供 transaction 应用能力
-
-## 7.2 建议直接参考的实现点
-
-- `EditorContent` 的封装模式
-- `BubbleMenu` 的接入方式
-- heading / list / blockquote / codeBlock 扩展配置
-- `editor.chain().focus()` 命令调用模式
-- selection 变化监听
-
-## 7.3 DeerFlow 本次落点
-
-- `frontend-web/src/open-canvas-writing/editor/TiptapEditor.tsx`
-- `frontend-web/src/open-canvas-writing/editor/TiptapExtensions.ts`
-- `frontend-web/src/open-canvas-writing/editor/commands.ts`
-- `frontend-web/src/open-canvas-writing/components/WritingBubbleMenu.tsx`
-
----
-
-## 8. DeerFlow 现有文件到新模块的映射
-
-## 8.1 `frontend-web/src/pages/PageRoutes.tsx`
-
-### 当前职责
-
-- 汇总页面路由
-
-### 本次作用
-
-- 挂入新的写作助手路由
-
-### 后续动作
-
-- 引入 `WritingRoutes`
-- 增加 `page/writing/*`
-
----
-
-## 8.2 `frontend-web/src/components/workspace/chats/chat-box.tsx`
-
-### 当前职责
-
-- 左聊天 + 右 Artifact 双栏布局
-
-### 本次作用
-
-- 提供双栏工作区组织思路
-- 可复用布局比例和 panel 交互经验
-
-### 不建议直接复用的部分
-
-- 不要继续让右侧核心能力挂在 ArtifactFileDetail 上
-
-### 本次目标替代
-
-- `WritingWorkspacePage.tsx`
-- `WritingShell.tsx`
-
----
-
-## 8.3 `frontend-web/src/components/workspace/artifacts/context.tsx`
-
-### 当前职责
-
-- 管理文件型 artifact 列表、选中项和开关状态
-
-### 本次作用
-
-- 仅作为旧 Artifact 模块保留
-
-### 本次目标替代
-
-- `WritingEditorContext.tsx`
-
-### 原因
-
-- 写作编辑器需要的不是文件路径状态
-- 而是文档状态、选区状态、候选结果状态、工具层状态
-
----
-
-## 8.4 `frontend-web/src/components/workspace/input-box.tsx`
-
-### 当前职责
-
-- 聊天输入区
-- 已有 `writing_mode` 入口
-
-### 本次作用
-
-- 保留为用户进入写作模式的现有入口
-
-### 本次改造建议
-
-- 写作模式打开时，跳转或唤起新的写作工作区
-- 不再只停留在“生成 Markdown 文件”这个层面
-
----
-
-## 9. 新模块间的依赖关系
-
-## 9.1 页面层
-
-- `WritingRoutes.tsx`
-- `WritingWorkspacePage.tsx`
-- `WritingShell.tsx`
-
-职责：
-
-- 页面路由
-- 双栏或工作区布局
-- 上下文装配
-
-## 9.2 编辑器层
-
-- `TiptapEditor.tsx`
-- `TiptapExtensions.ts`
-- `commands.ts`
-- `selection.ts`
-
-职责：
-
-- 编辑器内核
-- 节点和 marks
-- 基础命令
-- 选区抽取
-
-## 9.3 交互层
-
-- `WritingToolbar.tsx`
-- `WritingBubbleMenu.tsx`
-- `WritingAiMenu.tsx`
-- `WritingRewritePreview.tsx`
-
-职责：
-
-- 工具栏
-- 浮层
-- AI 菜单
-- 候选内容应用
-
-## 9.4 状态层
-
-- `WritingEditorContext.tsx`
-- `useWritingEditor.ts`
-- `useWritingSelection.ts`
-- `useWritingRewrite.ts`
-- `useWritingToolbar.ts`
-
-职责：
-
-- 主状态
-- 选区状态
-- 改写状态
-- 工具栏状态
-
-## 9.5 API 层
-
-- `api/rewrite.ts`
-- `api/documents.ts`
-
-职责：
-
-- 对接后端写作改写接口
-- 对接文档加载与保存接口
-
----
-
-## 10. 能力到文件的精确映射
-
-| 能力 | 新文件 | 说明 |
-| --- | --- | --- |
-| 新写作页面 | `frontend-web/src/open-canvas-writing/pages/WritingWorkspacePage.tsx` | 承载整个新模式 |
-| 写作路由 | `frontend-web/src/open-canvas-writing/routes/WritingRoutes.tsx` | 统一路由入口 |
-| 页面外壳 | `frontend-web/src/open-canvas-writing/components/WritingShell.tsx` | 页面布局与容器 |
-| 文档头部 | `frontend-web/src/open-canvas-writing/components/WritingHeader.tsx` | 标题、状态 |
-| 主工具栏 | `frontend-web/src/open-canvas-writing/components/WritingToolbar.tsx` | 文档结构与格式工具 |
-| 正文编辑器 | `frontend-web/src/open-canvas-writing/editor/TiptapEditor.tsx` | Tiptap 核心封装 |
-| 扩展配置 | `frontend-web/src/open-canvas-writing/editor/TiptapExtensions.ts` | 节点和 marks |
-| 选区浮层 | `frontend-web/src/open-canvas-writing/components/WritingBubbleMenu.tsx` | 选区出现的悬浮条 |
-| AI 菜单 | `frontend-web/src/open-canvas-writing/components/WritingAiMenu.tsx` | 润色、扩写等动作 |
-| 改写预览 | `frontend-web/src/open-canvas-writing/components/WritingRewritePreview.tsx` | 候选内容展示与应用 |
-| 替换 / 插入 | `frontend-web/src/open-canvas-writing/utils/apply-rewrite.ts` | 应用候选结果 |
-| 编辑器状态 | `frontend-web/src/open-canvas-writing/context/WritingEditorContext.tsx` | 独立上下文 |
-| 改写请求 | `frontend-web/src/open-canvas-writing/api/rewrite.ts` | 调后端接口 |
-
----
-
-## 11. 开发时的参考顺序
-
-建议开发顺序如下：
-
-1. 先看 `PageRoutes.tsx`，确定路由接法
-2. 再看 `chat-box.tsx`，理解当前左右布局
-3. 然后起 `WritingWorkspacePage.tsx` 和 `WritingShell.tsx`
-4. 再接 `TiptapEditor.tsx`
-5. 再做 `WritingToolbar.tsx`
-6. 再做 `WritingBubbleMenu.tsx`
-7. 再做 `WritingAiMenu.tsx`
-8. 最后做 `WritingRewritePreview.tsx`
-
-这样可以让每一层都有稳定承载，不会出现“先做了 AI 菜单，但页面还没落点”的混乱情况。
-
----
-
-## 12. 明确哪些是“参考”，哪些是“目标”
-
-### 12.1 参考
-
-- 豆包：交互体验参考
-- Novel：页面和编辑器质感参考
-- open-canvas：AI 工作流参考
-- Tiptap：编辑器技术实现参考
-
-### 12.2 目标
-
-目标不是复刻任何一个外部项目，而是：
-
-- 在 DeerFlow 现有架构中
-- 用 React + Vite + 现有线程体系
-- 做出一个更成熟的 AI 写作编辑器模式
-
----
-
-## 13. 结论
-
-这份映射表的核心作用，是避免团队在开发时迷路。
-
-真正推荐的姿势是：
-
-- 用豆包定义目标体验
-- 用 Novel 定义页面质感
-- 用 open-canvas 定义 AI 工作流
-- 用 Tiptap 作为编辑器内核
-- 用 DeerFlow 现有路由、线程、模型体系做宿主
-
-这样推进，既不会脱离你们现有工程，也能尽量快地把右侧编辑区拉到更接近成熟产品的水平。 

frontend-web/docs/ai-writing-backend-orchestrator-blueprint.md

@@ -1,645 +0,0 @@
-# AI 写作后端新路线设计草案
-
-## 1. 目标
-
-为“弱模型多 Agent 写作工作流”建设一条独立后端路线，满足以下要求：
-
-- 不影响现有同事正在开发的功能
-- 不强耦合现有 DeerFlow 通用对话主链路
-- 可独立部署、独立调试、独立回滚
-- 支持多阶段写作编排、人工介入、失败重试、流式事件输出
-
----
-
-## 2. 推荐建设方式
-
-优先建议：
-
-- 在 `offline-backend-20260512` 下新建独立应用或独立模块
-
-建议目录：
-
-```text
-offline-backend-20260512/
-  apps/
-    ai_writing_orchestrator/
-      api/
-      application/
-      domain/
-      infrastructure/
-      prompts/
-      tests/
-```
-
-如果当前后端没有 `apps/` 结构，也可以采用：
-
-```text
-offline-backend-20260512/
-  ai-writing-orchestrator/
-    api/
-    application/
-    domain/
-    infrastructure/
-    prompts/
-    tests/
-```
-
-重点不是目录名字，而是一定要把“多 Agent 写作编排”与现有通用聊天能力隔离开。
-
----
-
-## 3. 技术路线建议
-
-推荐组合：
-
-- 编排框架：`LangGraph`
-- 模型调用：接你们内网模型网关
-- 检索层：接内网知识库 / 文档库 / 搜索服务
-- 状态存储：先用数据库或 Redis + DB，后续再演进
-- 事件输出：SSE 或流式 HTTP
-
-推荐原因：
-
-- `LangGraph` 适合状态机和多节点回退
-- 对弱模型最关键的是“强流程控制”，不是“自由 Agent 对话”
-- 后续加人工确认节点和 checkpoint 会更自然
-
----
-
-## 4. 分层设计
-
-建议按四层拆分。
-
-## 4.1 API 层
-
-职责：
-
-- 接收前端请求
-- 鉴权
-- 参数校验
-- 返回 workflow 信息
-- 提供事件流出口
-
-建议文件：
-
-```text
-api/
-  routes/
-    workflows.py
-    workflow_events.py
-  schemas/
-    workflow_request.py
-    workflow_response.py
-```
-
-## 4.2 Application 层
-
-职责：
-
-- 组织用例
-- 调度 workflow service
-- 管理人工确认动作
-- 处理重试和终止逻辑
-
-建议文件：
-
-```text
-application/
-  services/
-    workflow_service.py
-    workflow_event_service.py
-    human_action_service.py
-  use_cases/
-    create_workflow.py
-    start_workflow.py
-    confirm_outline.py
-    rewrite_section.py
-    approve_final.py
-```
-
-## 4.3 Domain 层
-
-职责：
-
-- 定义工作流状态机
-- 定义 Agent 输入输出协议
-- 定义 artifact 与评分模型
-
-建议文件：
-
-```text
-domain/
-  models/
-    workflow.py
-    workflow_stage.py
-    workflow_event.py
-    artifact.py
-    review_result.py
-  agents/
-    researcher.py
-    outliner.py
-    writer.py
-    editor.py
-    supervisor.py
-  graphs/
-    writing_graph.py
-  policies/
-    retry_policy.py
-    quality_policy.py
-```
-
-## 4.4 Infrastructure 层
-
-职责：
-
-- 访问模型网关
-- 访问检索服务
-- 访问数据库
-- 发送事件
-- 缓存与日志
-
-建议文件：
-
-```text
-infrastructure/
-  llm/
-    model_client.py
-  retrieval/
-    intranet_search_client.py
-    knowledge_base_client.py
-  persistence/
-    workflow_repository.py
-    artifact_repository.py
-  streaming/
-    sse_publisher.py
-  logging/
-    workflow_logger.py
-```
-
----
-
-## 5. 工作流最小闭环
-
-第一版建议只做如下状态机：
-
-1. `collect_materials`
-2. `generate_outline`
-3. `await_outline_confirmation`
-4. `write_draft`
-5. `review_draft`
-6. `rewrite_if_needed`
-7. `complete`
-
-终止规则：
-
-- 编辑评分达标则完成
-- 否则进入重写
-- 最多重写 2 次
-- 超过次数则标记 `human_intervention_required`
-
----
-
-## 6. Agent 模块设计
-
-## 6.1 Researcher
-
-输入：
-
-- 主题
-- 用户要求
-- 检索范围
-- 可用资料源
-
-输出：
-
-- `material_cards`
-- `facts`
-- `quotes`
-- `examples`
-- `risks`
-- `source_refs`
-
-程序职责：
-
-- 先做检索
-- 再把检索结果裁剪后送给模型
-- 输出必须结构化
-
-## 6.2 Outliner
-
-输入：
-
-- 用户要求
-- 研究结果
-
-输出：
-
-- `title_candidates`
-- `outline_sections`
-- `key_points_per_section`
-
-约束：
-
-- 提纲优先，不写正文
-
-## 6.3 Writer
-
-输入：
-
-- 已确认提纲
-- 素材卡片
-- 风格要求
-
-输出：
-
-- `draft_sections`
-- `section_source_refs`
-- `full_draft_markdown`
-
-建议：
-
-- 按章节分段生成，不要一次长文直出
-
-## 6.4 Editor
-
-输入：
-
-- 初稿
-- 提纲
-- 素材
-- 用户要求
-
-输出：
-
-- `issues`
-- `severity`
-- `score`
-- `rewrite_instructions`
-- `decision`
-
-规则：
-
-- 先查事实，再查结构，再查文风
-
-## 6.5 Supervisor
-
-输入：
-
-- 各阶段结果
-- 重试计数
-- 评分结果
-
-输出：
-
-- 下一跳节点
-- 是否需要人工确认
-- 是否结束
-
----
-
-## 7. Prompt 组织建议
-
-建议为每个 Agent 分开管理 prompt，不要写成一个超级 prompt。
-
-建议目录：
-
-```text
-prompts/
-  researcher/
-    system.txt
-    output_schema.json
-  outliner/
-    system.txt
-    output_schema.json
-  writer/
-    system.txt
-    output_schema.json
-  editor/
-    system.txt
-    output_schema.json
-  supervisor/
-    system.txt
-```
-
-原则：
-
-- 每个 Agent 一套职责
-- 每个 Agent 一套输出 schema
-- Prompt 版本可管理
-- 后续支持 A/B 调参
-
----
-
-## 8. 弱模型适配策略
-
-## 8.1 先检索后生成
-
-不要让模型自己“想资料”，程序先检索、裁剪、去重后再喂给模型。
-
-## 8.2 短上下文任务化
-
-每个节点只给弱模型一小段明确任务：
-
-- 研究归纳
-- 提纲整理
-- 单章节写作
-- 单章节审稿
-
-## 8.3 结构化输出
-
-优先 JSON 或 Pydantic schema，不要放任自然语言自由返回。
-
-## 8.4 章节级重写
-
-不要整篇回炉。编辑指出第 2 节有问题，就只重写第 2 节。
-
-## 8.5 程序接管质量门槛
-
-例如：
-
-- 资料引用数不足，不进入下一步
-- 提纲章节数过少，直接重生
-- 编辑评分低于阈值，自动重写
-
----
-
-## 9. 数据模型建议
-
-## 9.1 Workflow
-
-建议字段：
-
-- `id`
-- `status`
-- `current_stage`
-- `user_id`
-- `thread_id`
-- `input_payload`
-- `current_artifact_id`
-- `retry_count`
-- `created_at`
-- `updated_at`
-
-## 9.2 Workflow Artifact
-
-建议字段：
-
-- `id`
-- `workflow_id`
-- `artifact_type`
-- `stage`
-- `version`
-- `title`
-- `content`
-- `metadata`
-
-## 9.3 Workflow Event
-
-建议字段：
-
-- `id`
-- `workflow_id`
-- `event_type`
-- `stage`
-- `agent_name`
-- `payload`
-- `created_at`
-
-## 9.4 Human Action
-
-建议字段：
-
-- `workflow_id`
-- `action_type`
-- `payload`
-- `operator`
-- `created_at`
-
----
-
-## 10. API 草案
-
-## 10.1 创建任务
-
-`POST /api/ai-writing/workflows`
-
-请求：
-
-```json
-{
-  "topic": "主题",
-  "articleType": "行业分析",
-  "audience": "管理层",
-  "tone": "专业克制",
-  "targetLength": 3000,
-  "constraints": ["避免口语化"],
-  "referenceScope": ["内网知识库", "项目复盘文档"]
-}
-```
-
-返回：
-
-```json
-{
-  "workflowId": "wf_xxx",
-  "status": "idle"
-}
-```
-
-## 10.2 启动任务
-
-`POST /api/ai-writing/workflows/{id}/start`
-
-## 10.3 查询任务
-
-`GET /api/ai-writing/workflows/{id}`
-
-## 10.4 订阅事件
-
-`GET /api/ai-writing/workflows/{id}/events`
-
-返回事件流示例：
-
-```json
-{
-  "type": "stage_changed",
-  "stage": "generating_outline",
-  "message": "正在生成提纲"
-}
-```
-
-## 10.5 确认提纲
-
-`POST /api/ai-writing/workflows/{id}/confirm-outline`
-
-## 10.6 指定章节重写
-
-`POST /api/ai-writing/workflows/{id}/rewrite-section`
-
-## 10.7 确认终稿
-
-`POST /api/ai-writing/workflows/{id}/approve-final`
-
----
-
-## 11. LangGraph 实现建议
-
-## 11.1 推荐 graph 节点
-
-- `load_input`
-- `retrieve_materials`
-- `normalize_materials`
-- `generate_outline`
-- `wait_for_outline_confirmation`
-- `write_sections`
-- `merge_sections`
-- `review_draft`
-- `rewrite_sections`
-- `publish_final_artifact`
-
-## 11.2 推荐 state
-
-建议 state 字段：
-
-- `workflow_id`
-- `input_payload`
-- `materials`
-- `outline`
-- `outline_confirmed`
-- `draft_sections`
-- `merged_draft`
-- `review_result`
-- `rewrite_targets`
-- `final_article`
-- `retry_count`
-- `events`
-
-## 11.3 条件边
-
-建议条件边逻辑：
-
-- 提纲未确认 -> 等待用户
-- 编辑通过 -> 完成
-- 编辑不通过且可重试 -> 重写
-- 编辑不通过且超限 -> 人工介入
-
----
-
-## 12. 可观测性要求
-
-第一版就建议带上以下能力：
-
-- 每个 workflow 的事件日志
-- 每个 Agent 的输入输出摘要
-- 每次重试原因
-- 每个阶段耗时
-- 每次模型调用 token 与错误日志
-
-后续排问题会非常依赖这些数据。
-
----
-
-## 13. 测试建议
-
-## 13.1 单元测试
-
-覆盖：
-
-- stage 流转
-- retry policy
-- quality policy
-- 事件构造
-
-## 13.2 集成测试
-
-覆盖：
-
-- 创建任务到完成的主链路
-- 提纲确认链路
-- 审稿失败后重写链路
-- 人工介入链路
-
-## 13.3 Prompt 回归集
-
-建议建立 10-20 个固定写作样例，做回归：
-
-- 短文
-- 长文
-- 事实密集型文章
-- 宣传型文章
-- 分析型文章
-
----
-
-## 14. 开发顺序建议
-
-## Step 1：先做 domain 与 API 契约
-
-先定：
-
-- stage 枚举
-- event 枚举
-- artifact 结构
-- human action payload
-
-## Step 2：先做 fake orchestrator
-
-先不接真实模型，只模拟事件流，把前后端联调跑通。
-
-## Step 3：接 Researcher + Outliner
-
-优先把“研究 + 提纲”做出来，因为这是弱模型提升最大的环节。
-
-## Step 4：接 Writer + Editor
-
-再接初稿和审稿重写。
-
-## Step 5：接可观测性和缓存
-
-最后再补生产化能力。
-
----
-
-## 15. 风险控制建议
-
-### 风险 1：直接复用现有线程流，导致协议污染
-
-建议：
-
-- workflow 用独立 route 和独立 event schema
-
-### 风险 2：写作结果与右侧 artifact 模型不兼容
-
-建议：
-
-- 后端统一输出标准 markdown artifact
-
-### 风险 3：弱模型频繁输出不合法 JSON
-
-建议：
-
-- 每个节点加 schema repair
-- 加轻量重试
-- 尽量减少复杂嵌套输出
-
-### 风险 4：研究资料太多导致上下文爆炸
-
-建议：
-
-- 检索后先裁剪、摘要、分桶
-
----
-
-## 16. 最终建议
-
-后端第一版最重要的是把“状态机、事件流、人工确认、章节重写”这四件事做对，而不是一开始就追求很多花哨 Agent。
-
-建议 MVP 只保留：
-
-1. Researcher
-2. Outliner
-3. Writer
-4. Editor
-5. Supervisor
-
-当这条链路稳定后，再继续扩展 fact-checker、style editor、compliance reviewer。

frontend-web/docs/ai-writing-final-execution-plan.md

@@ -1,806 +0,0 @@
-# AI 写作执行方案
-
-## 1. 总体原则
-
-本项目的最终落地原则：
-
-1. 前端继续基于当前 `open-canvas` 页面开发，不复制第二套页面
-2. 后端单独开 `ai-writing-orchestrator` 新路线，不侵入现有主链路
-3. 编排框架采用 `LangGraph`
-4. 写作工作流采用 `Researcher -> Outliner -> Writer -> Editor -> Supervisor`
-5. Agent 间输出统一采用 `JSON Schema / Pydantic`
-6. 前后端通过 `SSE` 传递工作流事件
-7. 第一版只做最小闭环，不做过多花哨扩展
-
-一句话说明：
-
-用独立的新后端路线承载多 Agent 写作工作流，前端继续复用 `open-canvas`，实现上采用 `LangGraph + A/B/C Agent + SSE` 的最小闭环。
-
----
-
-## 2. 项目边界
-
-## 2.1 前端边界
-
-继续使用当前页面：
-
-- [CanvasResizableLayout.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/layout/CanvasResizableLayout.tsx)
-- [CanvasChatPanel.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/chat/CanvasChatPanel.tsx)
-- [CanvasArtifactPanel.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/artifact/CanvasArtifactPanel.tsx)
-
-前端做的事情：
-
-- 左侧增加“写作工作流模式”
-- 展示多 Agent 执行进度与中间产物
-- 提供提纲确认和指定章节重写
-- 将初稿、终稿同步到右侧 artifact
-
-前端不做的事情：
-
-- 不重写右侧编辑器
-- 不重写现有普通 chat 流程
-- 不把 workflow 状态散落在多个旧 context 里
-
-## 2.2 后端边界
-
-后端采用独立新路线：
-
-推荐目录：
-
-```text
-offline-backend-20260512/
-  apps/
-    ai_writing_orchestrator/
-      api/
-      application/
-      domain/
-      infrastructure/
-      prompts/
-      tests/
-```
-
-后端做的事情：
-
-- 实现写作 workflow 状态机
-- 实现 A/B/C Agent 与 Supervisor
-- 接内网模型与内网检索
-- 输出标准事件流和文章 artifact
-
-后端不做的事情：
-
-- 不直接改现有 DeerFlow 主流程
-- 不把工作流逻辑塞到现有通用 thread 协议里
-
-## 2.3 资料搜集边界
-
-第一版处于互联网开发阶段，因此研究员的资料搜集先走互联网检索，不接内网检索服务。
-
-第一版要求：
-
-- 研究员可以调用互联网搜索能力收集公开资料
-- 研究结果必须保留来源 URL、标题、摘要、抓取时间
-- 检索层必须抽象成统一接口，不能把互联网搜索逻辑写死在 Agent prompt 或 graph 节点里
-
-第二版预留：
-
-- 后续替换或并行接入内网搜索接口
-- 后续接入内部知识库、文档库、FAQ、项目复盘库
-- 前端和工作流层不因检索源变化而改协议
-
-统一设计要求：
-
-- `Researcher` 只依赖“检索接口”，不依赖具体是互联网还是内网
-- `writing_graph` 只读取标准化后的素材结果
-- API、事件流、artifact 结构不区分互联网资料和内网资料
-
-推荐检索抽象：
-
-```text
-infrastructure/
-  retrieval/
-    base.py
-    internet_search_client.py
-    intranet_search_client.py
-    retriever_router.py
-```
-
-建议接口：
-
-```python
-class RetrievalProvider(Protocol):
-    def search(self, query: str, top_k: int) -> list[RetrievedDocument]: ...
-
-class RetrievedDocument(BaseModel):
-    title: str
-    url: str | None
-    source_type: str
-    snippet: str
-    published_at: str | None = None
-    fetched_at: str
-    reliability: str | None = None
-```
-
-第一版路由策略：
-
-- 默认 `internet`
-- 配置项预留 `intranet`、`hybrid`
-
-例如：
-
-```yaml
-retrieval:
-  provider: internet
-  top_k: 8
-  timeout_seconds: 15
-```
-
-这样第一版先跑公网资料，后续切换内网时，只替换 `retriever_router` 和对应 provider，不改 workflow 主逻辑。
-
----
-
-## 3. 第一版产品目标
-
-用户在 `open-canvas` 中选择“写作工作流模式”后，可以完成以下流程：
-
-1. 输入主题、体裁、读者、风格、篇幅
-2. 研究员搜集资料并输出素材卡片
-3. 提纲 Agent 生成提纲
-4. 用户确认提纲
-5. Writer 生成初稿
-6. Editor 给出问题清单与评分
-7. 不达标则重写一次或两次
-8. 终稿写入右侧 artifact
-
-第一版成功标准：
-
-- 不是“生成得像最强模型一样好”
-- 而是“明显优于单轮直出，并且流程可控、可回退、可人工介入”
-
-## 3.1 第一版研究员目标
-
-第一版 `Researcher` 的核心职责，不是“写文章”，而是“给 Writer 准备可信、可引用、可筛选的素材”。
-
-第一版输入：
-
-- 用户主题
-- 用户写作要求
-- 检索源配置，第一版默认 `internet`
-
-第一版输出至少包含：
-
-- `material_cards`
-- `facts`
-- `quotes`
-- `examples`
-- `risks`
-- `source_refs`
-
-每条素材最少要带：
-
-- 来源标题
-- 来源 URL
-- 摘要
-- 可信度标签
-- 被引用的原始片段或整理后的事实点
-
-第一版 Researcher 的程序流程建议：
-
-1. 根据主题自动生成 3-5 个检索 query
-2. 调用互联网检索接口拿回候选文档
-3. 做去重、裁剪、初筛
-4. 让模型将结果整理成结构化素材卡片
-5. 将结构化结果返回给 Outliner 和 Writer
-
-第一版先不做：
-
-- 深度网页 crawling
-- 多轮自动追问式深研究
-- 内网知识库接入
-- 复杂引用格式生成
-
----
-
-## 4. 最终工作流
-
-## 4.1 Agent 角色
-
-### `Researcher`
-
-职责：
-
-- 从配置的检索源检索信息
-- 产出结构化素材卡片
-- 标注来源、可信度、风险点
-
-第一版说明：
-
-- 默认走互联网公开资料检索
-- 必须预留后续切换到内网检索源的接口
-- 检索实现放在 `infrastructure/retrieval/`，不要写死在 prompt 中
-
-第一版检索源字段建议：
-
-- `source_type = "internet"`
-- 后续预留 `source_type = "intranet" | "hybrid"`
-
-输出：
-
-- `material_cards`
-- `facts`
-- `quotes`
-- `examples`
-- `risks`
-- `source_refs`
-
-### `Outliner`
-
-职责：
-
-- 根据用户要求和研究结果生成提纲
-
-输出：
-
-- `title_candidates`
-- `outline_sections`
-- `key_points_per_section`
-
-### `Writer`
-
-职责：
-
-- 基于提纲和素材写初稿
-- 按章节写，不一次生成整篇长文
-
-输出：
-
-- `draft_sections`
-- `section_source_refs`
-- `full_draft_markdown`
-
-### `Editor`
-
-职责：
-
-- 检查事实、结构、文风
-- 给出评分与重写建议
-
-输出：
-
-- `issues`
-- `severity`
-- `score`
-- `rewrite_instructions`
-- `decision`
-
-### `Supervisor`
-
-职责：
-
-- 负责流程调度
-- 负责通过 / 重写 / 人工介入判断
-
-## 4.2 状态机
-
-第一版统一采用：
-
-- `idle`
-- `collecting_materials`
-- `generating_outline`
-- `await_outline_confirmation`
-- `writing_draft`
-- `reviewing_draft`
-- `rewriting_draft`
-- `completed`
-- `failed`
-- `human_intervention_required`
-
-## 4.3 流程闭环
-
-最小闭环固定为：
-
-1. `Research`
-2. `Outline`
-3. `HumanConfirmOutline`
-4. `Draft`
-5. `Review`
-6. `RewriteIfNeeded`
-7. `Complete`
-
-重试规则：
-
-- 最多重写 2 次
-- 达标则完成
-- 超限则进入人工介入
-
-## 4.4 LangGraph 推荐节点
-
-第一版推荐节点：
-
-- `load_input`
-- `build_search_queries`
-- `retrieve_materials`
-- `normalize_materials`
-- `generate_outline`
-- `wait_for_outline_confirmation`
-- `write_sections`
-- `merge_sections`
-- `review_draft`
-- `rewrite_sections`
-- `publish_final_artifact`
-
-其中和资料搜集直接相关的节点说明：
-
-### `build_search_queries`
-
-职责：
-
-- 根据用户主题和目标文章类型，生成 3-5 个检索 query
-
-### `retrieve_materials`
-
-职责：
-
-- 调用检索 provider 获取候选文档
-- 第一版默认走 `internet_search_client`
-- 后续可切到 `intranet_search_client`
-
-### `normalize_materials`
-
-职责：
-
-- 做去重
-- 做摘要裁剪
-- 做来源字段统一
-- 输出标准 `RetrievedDocument[]`
-
----
-
-## 5. 前端最终做法
-
-## 5.1 目录建议
-
-在现有 `open-canvas` 下新增：
-
-```text
-frontend-web/src/open-canvas/
-  workflow/
-    api/
-      writing-workflow.ts
-    components/
-      WritingWorkflowEntryForm.tsx
-      WritingWorkflowTimeline.tsx
-      WritingWorkflowEventList.tsx
-      WritingWorkflowArtifactDrawer.tsx
-      WritingWorkflowConfirmCard.tsx
-      WritingWorkflowHeader.tsx
-      CanvasWorkflowPanel.tsx
-    contexts/
-      WritingWorkflowContext.tsx
-    hooks/
-      useWritingWorkflow.ts
-      useWritingWorkflowEvents.ts
-    types/
-      workflow.ts
-```
-
-## 5.2 左侧改造策略
-
-`CanvasChatPanel` 只承担模式切换与容器职责：
-
-- `chat` 模式：沿用现有普通聊天
-- `writing_pipeline` 模式：渲染 `CanvasWorkflowPanel`
-
-新面板负责：
-
-- 写作任务表单
-- 进度时间线
-- 事件列表
-- 中间产物抽屉
-- 提纲确认卡片
-
-## 5.3 右侧衔接策略
-
-继续复用现有 `CanvasArtifactPanel`。
-
-同步规则：
-
-- 提纲：可选同步到右侧预览
-- 初稿：同步到右侧
-- 重写稿：覆盖当前草稿
-- 终稿：作为最终 artifact
-
-## 5.4 前端状态设计
-
-新增：
-
-- `workflowMode`
-- `workflowRunId`
-- `workflowStage`
-- `workflowStatus`
-- `workflowEvents`
-- `workflowArtifacts`
-- `workflowPendingAction`
-
-注意：
-
-- workflow 状态放进新的 `WritingWorkflowContext`
-- 不塞进现有 `CanvasGraphContext`
-
-## 5.5 前端显示的资料信息
-
-第一版左侧至少要能展示研究员产出的资料摘要：
-
-- 来源标题
-- 来源域名或 URL
-- 资料摘要
-- 可信度标签
-- 是否被提纲或正文引用
-
-建议在 `WritingWorkflowArtifactDrawer.tsx` 中增加“素材卡片”视图。
-
-注意：
-
-- 第一版显示公开互联网来源即可
-- 后续接内网时，这个展示层不变，只是来源字段从 URL 变成内网文档标识或内部链接
-
----
-
-## 6. 后端最终做法
-
-## 6.1 分层
-
-推荐分层：
-
-```text
-api/
-application/
-domain/
-infrastructure/
-prompts/
-tests/
-```
-
-## 6.2 核心模块
-
-建议核心文件：
-
-```text
-domain/
-  models/
-    workflow.py
-    workflow_stage.py
-    workflow_event.py
-    artifact.py
-    review_result.py
-  agents/
-    researcher.py
-    outliner.py
-    writer.py
-    editor.py
-    supervisor.py
-  graphs/
-    writing_graph.py
-  policies/
-    retry_policy.py
-    quality_policy.py
-```
-
-## 6.3 检索层实现要求
-
-第一版检索层必须独立成基础设施模块，不允许：
-
-- 在 Agent prompt 中直接拼接“去网上找资料”
-- 在 graph 节点中散落请求第三方搜索的代码
-- 把互联网检索和内网检索混在一个无抽象的函数里
-
-建议结构：
-
-```text
-infrastructure/
-  retrieval/
-    base.py
-    internet_search_client.py
-    intranet_search_client.py
-    retriever_router.py
-    material_normalizer.py
-```
-
-建议职责：
-
-- `internet_search_client.py`
-  - 第一版实际使用
-  - 对接互联网搜索 API 或爬取网关
-
-- `intranet_search_client.py`
-  - 第一版只保留接口和空实现或 mock
-  - 后续接企业内部接口
-
-- `retriever_router.py`
-  - 根据配置选择 provider
-
-- `material_normalizer.py`
-  - 统一清洗和标准化结果
-
-## 6.4 Prompt 管理
-
-统一独立存放：
-
-```text
-prompts/
-  researcher/
-    system.txt
-    output_schema.json
-  outliner/
-    system.txt
-    output_schema.json
-  writer/
-    system.txt
-    output_schema.json
-  editor/
-    system.txt
-    output_schema.json
-  supervisor/
-    system.txt
-```
-
-## 6.5 输出约束
-
-每个 Agent 都必须：
-
-- 优先输出 JSON / Pydantic schema
-- 失败时允许轻量 repair 和一次重试
-- 避免自由散文式输出
-
-## 6.6 Researcher 的实现细则
-
-Researcher 推荐由两部分组成：
-
-1. 程序化检索
-2. 模型化整理
-
-推荐伪流程：
-
-```python
-def run_research(topic: str, article_type: str, provider: RetrievalProvider):
-    queries = build_queries(topic, article_type)
-    raw_docs = []
-    for query in queries:
-        raw_docs.extend(provider.search(query=query, top_k=5))
-    docs = normalize_materials(raw_docs)
-    docs = dedupe_materials(docs)
-    docs = rank_materials(docs)
-    return llm_extract_material_cards(docs)
-```
-
-第一版建议：
-
-- 先把 query 生成逻辑做简单
-- `top_k` 先控制在 5-10
-- 先做轻量去重和摘要裁剪
-- 不做很重的网页全文抓取
-
----
-
-## 7. 前后端协议
-
-## 7.1 API
-
-第一版统一提供：
-
-- `POST /api/ai-writing/workflows`
-- `POST /api/ai-writing/workflows/{id}/start`
-- `GET /api/ai-writing/workflows/{id}`
-- `GET /api/ai-writing/workflows/{id}/events`
-- `POST /api/ai-writing/workflows/{id}/confirm-outline`
-- `POST /api/ai-writing/workflows/{id}/rewrite-section`
-- `POST /api/ai-writing/workflows/{id}/approve-final`
-
-## 7.2 SSE 事件
-
-统一事件类型：
-
-- `workflow_started`
-- `stage_changed`
-- `agent_started`
-- `agent_output_chunk`
-- `artifact_generated`
-- `human_confirmation_required`
-- `retry_scheduled`
-- `workflow_completed`
-- `workflow_failed`
-
-第一版前端不需要消费复杂嵌套事件，只要先把这 9 类打通。
-
-## 7.3 配置项补充
-
-建议增加以下配置项：
-
-```yaml
-retrieval:
-  provider: internet
-  top_k: 8
-  timeout_seconds: 15
-  enable_content_fetch: false
-
-workflow:
-  max_revisions: 2
-
-models:
-  researcher: your-default-model
-  outliner: your-default-model
-  writer: your-default-model
-  editor: your-default-model
-```
-
-说明：
-
-- 第一版 `provider=internet`
-- 第二版可切成 `intranet` 或 `hybrid`
-
----
-
-## 8. 必须做 / 延后做 / 不建议现在做
-
-## 8.1 必须做
-
-### 架构
-
-- 独立后端路线 `ai-writing-orchestrator`
-- 前端独立 `workflow/` 目录
-- LangGraph 状态机
-- `Researcher / Outliner / Writer / Editor / Supervisor`
-- 独立检索抽象层，第一版先落互联网 provider
-
-### 协议
-
-- 标准 workflow 状态枚举
-- 标准 SSE 事件枚举
-- 标准 artifact 结构
-- JSON / Pydantic 输出约束
-
-### 功能
-
-- 启动写作任务
-- 研究阶段
-- 提纲阶段
-- 提纲确认
-- 初稿生成
-- 审稿与最多 2 次重写
-- 终稿同步到右侧
-- 素材卡片展示
-- 来源 URL、标题、摘要、可信度落库或挂在 artifact metadata
-
-### UI
-
-- 模式切换
-- 时间线
-- 事件列表
-- 提纲确认卡片
-- 右侧终稿显示
-- 左侧素材卡片视图
-
-## 8.2 延后做
-
-- 章节级精准重写
-- 初稿多版本树
-- FactChecker
-- StyleEditor
-- ComplianceReviewer
-- 自动评分看板
-- 素材引用可视化高亮
-- 更复杂的人机协作节点
-- 内网知识库正式接入
-- 混合检索 `hybrid`
-- 网页全文抓取与深摘要
-
-## 8.3 不建议现在做
-
-- 直接接入现有 DeerFlow 主 agent 包
-- 同时试 MetaGPT、CrewAI、AutoGen 多套底座
-- 一开始就做 5 个以上 Agent
-- 一开始就做很复杂的文章版本管理
-- 一开始就把评分阈值和 prompt 写死得非常细
-
-## 9. 最终开发顺序
-
-## Step 1：先定契约
-
-先一起拍板：
-
-- stage 枚举
-- event 枚举
-- artifact 结构
-- confirm / rewrite 的 payload
-- retrieval provider 接口
-- RetrievedDocument 结构
-
-## Step 2：先做 fake workflow
-
-后端先不接真实模型，只吐 mock SSE 事件，前端把左侧工作台跑通。
-
-## Step 3：先接互联网版 Researcher + Outliner
-
-优先打磨“研究 + 提纲”，这是弱模型提升最大的部分。
-
-这一阶段要求：
-
-- `Researcher` 先走互联网检索
-- `retriever_router` 可配置
-- `intranet_search_client` 先留接口空壳
-
-## Step 4：接 Writer + Editor
-
-再补初稿与审稿重写闭环。
-
-## Step 5：接右侧 artifact
-
-把初稿和终稿稳定写入右侧。
-
-## Step 6：补生产化
-
-- 缓存
-- 日志
-- 错误回放
-- 配置化 prompt
-
-## 10. 推荐任务拆分
-
-## 前端
-
-- `CanvasChatPanel` 模式切换
-- `workflow/` 目录与类型
-- 时间线 / 事件列表 / 确认卡片
-- SSE 订阅 hook
-- 右侧 artifact 映射
-- 素材卡片列表展示
-- 来源字段展示规范
-
-## 后端
-
-- workflow API
-- LangGraph graph
-- 5 个 Agent 模块
-- Prompt 目录
-- SSE 输出
-- 仓储与日志
-- `RetrievalProvider` 抽象
-- `internet_search_client`
-- `intranet_search_client` 预留接口
-- `material_normalizer`
-
-## Prompt / 算法
-
-- Researcher prompt
-- Outliner prompt
-- Writer prompt
-- Editor prompt
-- JSON schema
-- 失败样本回归
-
-## 联调
-
-- mock SSE
-- 真模型接入
-- artifact 同步校验
-- 提纲确认链路验证
-- 互联网资料来源字段联调
-- 素材卡片到提纲引用链路联调
-
----
-
-## 11. 开发过程中的约束
-
-开发过程中统一采用下面这套口径：
-
-- 产品形态：当前 `open-canvas` 页面上的“写作工作流模式”
-- 技术底座：`LangGraph`
-- 核心模式：`Researcher -> Outliner -> Writer -> Editor -> Supervisor`
-- 后端方式：独立 `ai-writing-orchestrator`
-- 检索方式：第一版 `internet`，接口预留 `intranet`
-- 通信方式：`SSE`
-- 输出方式：`JSON Schema / Pydantic`
-- 第一版目标：先做最小闭环，不追求角色数量和复杂度
-
-给开发团队的统一口径：
-
-“我们在 `open-canvas` 上开发写作工作流模式，后端单开 `ai-writing-orchestrator`，第一版先用互联网资料检索，保留内网检索接入口，用 LangGraph 编排 Researcher、Outliner、Writer、Editor、Supervisor，把研究、提纲、初稿、审稿重写这条最小闭环做稳。”

frontend-web/docs/ai-writing-frontend-dev.md

@@ -1,538 +0,0 @@
-# AI 写作 — 前端开发文档
-
-> **本文档目的**：帮助前端开发者快速理解 AI 写作子系统的代码结构、数据流、状态机和扩展点。
->
-> **配套文档**：
-> - `ai-writing-说明.md` — 故障排查与运维向解决方案
-> - `ai-writing-assistant-backend-api.md` — 后端 API 详细字段定义
-> - `ai-writing-assistant-source-map.md` — 旧版前端结构索引（已合并到本文档）
-
----
-
-## 一、产品定位
-
-AI 写作是 DeerFlow 的「**杂志社协作写作**」子产品，由 LangGraph 后端驱动 4 个 AI Agent（**素材收集专家 / 作家 / 编辑 / 系统**）协作完成一篇文章。用户通过 **4 个干预点**（素材确认、大纲确认、草稿确认、审核确认）参与决策，UI 实时呈现进度。
-
-### UI 入口
-- 路由：`/canvas/ai-writing`（在 `WorkspaceRoutes.tsx` 注册）
-- 入口页：`src/open-canvas/pages/AIWritingPage.tsx`
-- 双栏布局：左 AI 写作面板（聊天 + 干预），右草稿预览
-
----
-
-## 二、目录结构
-
-```
-frontend-web/src/open-canvas/
-├── pages/
-│   └── AIWritingPage.tsx              # 入口页（双栏 Resizable 布局）
-│
-├── api/                               # ── 后端 API 适配层 ──
-│   ├── ai-writing.ts                  # /start /resume + SSE 订阅（核心）
-│   ├── ai-writing-sessions.ts         # 历史会话 CRUD + transcript 保存
-│   └── ai-writing-article-types.ts    # 文章类型 CRUD
-│
-├── hooks/                             # ── 状态管理 ──
-│   ├── useAIWriting.ts                # 写作主状态机（最重要）
-│   ├── useAIWritingSessions.ts        # 历史会话列表 hook
-│   └── useArticleTypes.ts             # 文章类型选项 hook
-│
-├── components/ai-writing/             # ── UI 组件 ──
-│   ├── AIWritingPanel.tsx             # 左侧主面板（聊天 + 干预编排）
-│   ├── AIWritingDraftPanel.tsx        # 右侧草稿预览面板
-│   ├── AIWritingPageHeader.tsx        # 顶部标题/历史下拉
-│   ├── AIWritingForm.tsx              # 写作请求表单（首次启动用）
-│   │
-│   ├── AIWritingTimeline.tsx          # 时间线主容器
-│   ├── TimelineStep.tsx               # 单条进度事件
-│   ├── CompletedInterventionCard.tsx  # 已完成的干预记录
-│   │
-│   ├── InterventionCard.tsx           # 4 个干预点 + 求助点的卡片（核心）
-│   ├── MaterialsCard.tsx              # 素材确认
-│   ├── MaterialItem.tsx               # 单个素材项
-│   ├── MaterialsToolbar.tsx           # 素材筛选/搜索工具栏
-│   ├── OutlineCard.tsx                # 大纲确认（含编辑）
-│   ├── OutlineSection.tsx             # 大纲单章节
-│   ├── ReviewCard.tsx                 # 审核确认
-│   ├── IssueList.tsx                  # 审核意见列表
-│   ├── ScoreBar.tsx                   # 评分进度条
-│   │
-│   ├── OutlineStreamingView.tsx       # 大纲流式打字机
-│   ├── DraftStreamingView.tsx         # 草稿流式打字机
-│   ├── ReviewStreamingView.tsx        # 审核流式打字机
-│   ├── WritingSkeletonCard.tsx        # 加载骨架屏
-│   ├── RevisionSummaryCard.tsx        # 修改前后对比摘要
-│   │
-│   ├── AIWritingHistoryDropdown.tsx   # 历史会话下拉
-│   └── AIWritingHistoryView.tsx       # 历史会话只读回显
-│
-└── types/
-    └── ai-writing.ts                   # 全部类型定义（重要参考）
-```
-
----
-
-## 三、数据流总览
-
-```
-┌─────────────────────────────────────────────────────────────────┐
-│                       AIWritingPanel                            │
-│  ┌──────────────────────────────────────────────────────────┐   │
-│  │  useAIWriting() 主状态 hook                              │   │
-│  │  ┌────────────────────────────────────────────────────┐  │   │
-│  │  │  startWriting()  ─── POST /api/ai-writing/start    │  │   │
-│  │  │                       ↓ 返回 session_id            │  │   │
-│  │  │                                                    │  │   │
-│  │  │  subscribeToProgress(sessionId)                    │  │   │
-│  │  │      ─── GET /api/ai-writing/{id}/stream (SSE)     │  │   │
-│  │  │      ─── 持续推 ProgressEvent 给 handleEvent       │  │   │
-│  │  │      ─── handleEvent reducer → setState            │  │   │
-│  │  │                                                    │  │   │
-│  │  │  submitIntervention()                              │  │   │
-│  │  │      ─── POST /api/ai-writing/{id}/resume          │  │   │
-│  │  │      ─── graph 续推 → 新事件继续走 SSE             │  │   │
-│  │  │                                                    │  │   │
-│  │  │  saveAIWritingTranscript()（fire-and-forget）      │  │   │
-│  │  │      ─── PUT /api/ai-writing/sessions/{id}/transcript │ │
-│  │  └────────────────────────────────────────────────────┘  │   │
-│  └──────────────────────────────────────────────────────────┘   │
-│                                                                 │
-│  渲染：                                                         │
-│  ├ AIWritingForm（idle 状态）                                   │
-│  ├ AIWritingTimeline（运行中）                                  │
-│  │   ├ TimelineStep × N（progressEvents）                       │
-│  │   └ CompletedInterventionCard × N（已完成的干预）            │
-│  ├ {Outline,Draft,Review}StreamingView（流式打字机）            │
-│  ├ InterventionCard（当前 currentPause 存在时弹出）             │
-│  └ WritingSkeletonCard（运行中无 pause 时的骨架屏）             │
-└─────────────────────────────────────────────────────────────────┘
-```
-
----
-
-## 四、状态机（useAIWriting.ts）
-
-### 状态字段（完整定义见 `types/ai-writing.ts`）
-
-```typescript
-interface AIWritingState {
-  // —— 核心标识 ——
-  sessionId: string | null;         // 后端返回的会话 id
-  status: WritingStatus;            // 当前阶段（13 种状态之一）
-  isPaused: boolean;                // 是否在干预点等待用户
-  error: string | null;
-
-  // —— 配置 ——
-  request: AIWritingRequest | null; // 用户提交的写作请求
-
-  // —— 累计数据 ——
-  progressEvents: ProgressEvent[];  // SSE 事件全量历史（供时间线渲染）
-  materials: AIMaterial[];          // 素材列表（素材就绪后填充）
-  outline: AIOutline | null;        // 大纲（大纲就绪后填充）
-  currentDraftMarkdown: string;     // 草稿正文（草稿就绪后填充）
-  currentDraftTitle: string;
-  reviewResult: ReviewResult | null;
-  revisionCount: number;
-  completedInterventions: CompletedIntervention[];  // 已完成的干预历史
-
-  // —— 干预 ——
-  currentPause: ProgressEvent | null;  // 当前挂起的 await_user 事件
-
-  // —— 流式视图状态 ——
-  streamingDraftTitle: string;
-  streamingDraftSections: StreamingDraftSection[];
-  outlineStreamingText: string;
-  outlineThinkingText: string;
-  researchProgress: string;
-  streamingReviewItems: StreamingReviewItem[];
-  revisionSummary: RevisionSummary | null;
-  pendingRevisionContext: { /* ... */ } | null;
-}
-```
-
-### 状态转移图（写作状态机）
-
-```
-                ┌──────┐
-                │ idle │ ←─────────────────────────────────────┐
-                └──┬───┘                                       │
-                   │ startWriting()                            │
-                   ↓                                           │
-            ┌─────────────────┐                                │
-            │  researching    │                                │
-            └──┬──────────────┘                                │
-               ↓ materials_ready                               │
-            ┌─────────────────────────────┐                    │
-            │ awaiting_material_confirm   │ ← await_user       │
-            └──┬──────────────────────────┘                    │
-               ↓ submit(confirm)                               │
-            ┌─────────────────┐                                │
-            │ writing_outline │ ← (re_search 路径)             │
-            └──┬──────────────┘                                │
-               ↓ outline_ready                                 │
-            ┌─────────────────────────────┐                    │
-            │ awaiting_outline_confirm    │                    │
-            └──┬──────────────────────────┘                    │
-               ↓ submit(confirm)                               │
-            ┌─────────────────┐                                │
-            │ writing_draft   │ ← (re_outline 路径)            │
-            └──┬──────────────┘                                │
-               │                                               │
-       ┌───────┴────────┐                                      │
-       ↓                ↓                                      │
-  awaiting_section_   awaiting_draft_confirm                   │
-   help (素材不足)    └─┬───┬───┬──────────────┐               │
-       │ (supplement)   │   │   │ to_editor    │               │
-       │ ↑回到 research │   │   ↓              │               │
-       │                │   │ reviewing        │               │
-       │                │   │ └─┬──────┐       │               │
-       │                │   │   ↓      ↓      │               │
-       │                │   │ awaiting_review_confirm          │
-       │                │   │   └─┬────────┐                   │
-       │                │   │     ↓ submit  ↓                  │
-       │                │   │   revising   done ───────────────┘
-       │                │   │     │
-       │                │   │     └─→ writing_draft (循环修订)
-       │                │   │
-       │                │   │ user_revise
-       │                │   └─→ revising
-       │                │
-       │                │ finalize
-       │                └─→ done
-       │
-       └──→ (delete/loose) writing_draft 继续
-```
-
-### handleEvent reducer（核心）
-
-`useAIWriting.ts` 里的 `handleEvent` 是个**纯 reducer**，根据 SSE 事件类型更新状态：
-
-| 事件类型 | 主要影响的状态字段 |
-|---|---|
-| `connected` | 仅记录到 progressEvents |
-| `step_start` | 切到对应 `status`（如「编辑」→ reviewing） |
-| `step_done` | 仅记录 |
-| `research_progress` | `researchProgress`（实时检索进度文案） |
-| `materials_ready` | `materials`、清空 researchProgress |
-| `outline_chunk` | `outlineStreamingText` / `outlineThinkingText`（打字机） |
-| `outline_ready` | `outline`、清空流式文本 |
-| `draft_chunk` | `streamingDraftSections`（按章节拼接打字机） |
-| `draft_ready` | `currentDraftMarkdown` / `currentDraftTitle` |
-| `review_chunk` | `streamingReviewItems[i].streamingText`（逐条打字机） |
-| `review_item_done` | `streamingReviewItems[i]` 标记 isDone + 结构化结果 |
-| `review_ready` | `reviewResult` |
-| `await_user` | `currentPause = event`，`isPaused = true`，**弹出 InterventionCard** |
-| `resumed` | `currentPause = null` |
-| `notice` | 仅记录（非致命告警） |
-| `done` | `status = 'done'` |
-| `error` | `status = 'error'`，`error = event.message` |
-
----
-
-## 五、API 层（api/）
-
-### 1. `api/ai-writing.ts` — 核心写作 API
-
-```typescript
-// 启动写作 → 返回 session_id
-export async function startWritingSession(req: AIWritingRequest): Promise<string>
-
-// 订阅 SSE 进度流 → 返回取消订阅函数
-export function subscribeToProgress(
-  sessionId: string,
-  onEvent: (event: ProgressEvent) => void,
-): () => void
-
-// 提交用户干预 → 让 graph 续推
-export async function resumeWriting(
-  sessionId: string,
-  payload: UserInterventionPayload,
-): Promise<void>
-```
-
-**关键实现细节**：
-- **snake_case ↔ camelCase 转换**：后端返回 snake_case，前端类型是 camelCase。所有 normalize 函数（`normalizeMaterial`、`normalizeOutlineSection`...）集中在这一层做转换
-- **SSE 事件白名单**：`SSE_EVENT_TYPES` 数组列出所有合法事件名，未知事件会被静默忽略
-- **取消订阅**：`subscribeToProgress` 返回的函数会调用 `AbortController.abort()` 关闭 fetch stream
-- **重连机制**：当前**没有内置重连** — 如果 SSE 断开（网络抖动、反代超时），需要用户主动重启写作或刷新页面
-  - 后端 `_recover_session` 能让 SSE 重连时从 checkpointer 恢复事件，但前端没主动重连逻辑
-
-### 2. `api/ai-writing-sessions.ts` — 历史会话
-
-```typescript
-// CRUD
-listAIWritingSessions()                  : Promise<AIWritingSessionSummary[]>
-getAIWritingSession(id)                  : Promise<AIWritingSessionSummary>
-renameAIWritingSession(id, title)        : Promise<AIWritingSessionSummary>
-deleteAIWritingSession(id)               : Promise<void>
-
-// 时间线持久化（fire-and-forget，永不抛错）
-saveAIWritingTranscript(id, transcript)  : Promise<boolean>
-```
-
-**关键设计**：`saveAIWritingTranscript` 内部用 try/catch 吞掉所有异常（网络错误、HTTP 500 等），只 `console.warn` 不影响主流程。这是**「锦上添花」契约**的前端侧。
-
-### 3. `api/ai-writing-article-types.ts` — 文章类型管理
-
-| 函数 | 用途 |
-|---|---|
-| `listArticleTypes()` | 表单下拉框选项 |
-| `createArticleType()` | 管理员新增 |
-| `updateArticleType()` | 管理员编辑 |
-| `deleteArticleType()` | 管理员删除 |
-
----
-
-## 六、组件树详解
-
-### 顶层：`AIWritingPanel`（457 行，最大）
-
-负责：
-1. 调用 `useAIWriting()` 拿主状态
-2. 调用 `useAIWritingSessions()` 拿历史列表
-3. 协调表单 / 时间线 / 干预卡 / 流式视图 / 草稿同步
-4. **自动滚底逻辑**：检测用户是否手动上划，决定是否跟随最新内容
-5. **草稿同步到右侧画布**：监听 `currentDraftMarkdown` 变化，调 `setArtifact` 更新右侧
-6. **历史会话回显**：当 `historySession` 非空时，渲染 `AIWritingHistoryView` 而不是实时面板
-
-### 干预卡：`InterventionCard`（663 行，第二大）
-
-按 `pausePoint` 渲染**不同的卡片**：
-
-| pausePoint | 卡片 | 用户能做的 |
-|---|---|---|
-| `material_confirm` | `MaterialsCard` | 勾选保留素材 / 加关键词重新搜 |
-| `outline_confirm` | `OutlineCard` | 直接编辑大纲 / 给反馈让重写 |
-| `draft_confirm` | 草稿确认卡 | 定稿 / 给修订意见 / 提交编辑审核 |
-| `review_confirm` | `ReviewCard` | 勾选采纳的意见 / 强制通过 |
-| `section_help` | 求助卡 | 逐章选择：补充检索 / 删除 / 按通用知识续写 |
-
-### 时间线：`AIWritingTimeline`
-
-迭代 `progressEvents`，每个 `step_start` / `step_done` / `notice` 渲染成一条 `TimelineStep`。`CompletedInterventionCard` 穿插显示已完成的干预记录。
-
-### 流式视图：`{Outline,Draft,Review}StreamingView`
-
-- **OutlineStreamingView**：打字机渲染 `outlineStreamingText`，支持 `<think>...</think>` 折叠显示
-- **DraftStreamingView**：按章节流式拼接 `streamingDraftSections`，每章节独立打字机
-- **ReviewStreamingView**：3 条审核（事实 / 逻辑 / 语言）并行打字机，完成后切到结构化评分
-
-### 历史回显：`AIWritingHistoryView`
-
-只读模式，从 `AIWritingSessionSummary` 重建 UI。**当 `transcript` 字段有值时**，从里面拿到完整 `progressEvents`，UI 表现跟实时一模一样。`transcript` 没有时退回到只显示最终草稿。
-
----
-
-## 七、SSE 事件协议（前后端契约）
-
-后端通过 SSE 推 `event: <type>\ndata: <json>\n\n` 格式，前端用浏览器原生 `fetch + ReadableStream` 解析（不用 `EventSource`，因为 EventSource 不能自定义 header）。
-
-### 解析流程
-
-```
-ReadableStream → TextDecoder
-              → 按 "\n\n" 分帧
-              → 每帧匹配 /^event: (.+)\ndata: (.+)$/
-              → JSON.parse(data)
-              → normalize(parsed)（snake → camel）
-              → onEvent(normalized)
-```
-
-### 事件载荷字段（不完全列表）
-
-| 字段 | 出现在哪些事件 | 用途 |
-|---|---|---|
-| `type` | 全部 | 事件类别 |
-| `sessionId` | 全部 | 标识 |
-| `message` | 大多数 | 显示给用户的文案 |
-| `agentName` | step_*  | 「素材收集专家」/「作家」/「编辑」/「系统」 |
-| `materials` | materials_ready | 素材数组 |
-| `outline` | outline_ready | 大纲对象 |
-| `draftMarkdown` / `draftTitle` | draft_ready | 草稿内容 |
-| `reviewResult` | review_ready | 完整审核结果 |
-| `pausePoint` | await_user | 哪个干预点 |
-| `pauseContext` | await_user | 干预所需的上下文（如待确认的素材列表） |
-| `blockedSections` | await_user (section_help) | 素材不足的章节列表 |
-| `title` / `detail` / `raw` | notice / error | 非致命告警的标题、详情、原始错误 |
-
----
-
-## 八、扩展指南：常见开发任务
-
-### 新增一个干预点
-
-1. **前端类型扩展**：
-   - 在 `types/ai-writing.ts` 的 `ProgressEvent.pausePoint` 联合类型里加新 case
-   - 在 `WritingStatus` 加对应的 `awaiting_xxx`
-   - 在 `CompletedIntervention.pausePoint` 加 case
-
-2. **写 InterventionCard 分支**：在 `InterventionCard.tsx` 里加新 `pausePoint` 分支，做 UI + 提交逻辑
-
-3. **后端配合**（详见后端开发文档）：
-   - `graph.py` 加 `pause_xxx_confirm` 节点
-   - graph 拓扑加这个节点的边
-
-4. **完成干预后的清理**：在 `useAIWriting.ts` 的 `submitIntervention` 函数里，**确保把这次干预 push 到 `completedInterventions`**，让历史能看到
-
-### 新增一个 SSE 事件类型
-
-1. `types/ai-writing.ts`：
-   - `ProgressEventType` 联合类型加新值
-   - `ProgressEvent` 接口加新字段（如果有载荷）
-
-2. `api/ai-writing.ts`：
-   - `SSE_EVENT_TYPES` 数组加新值（不加会被忽略）
-   - `normalizeEvent` 函数里加字段转换（如果是 snake_case 需要 normalize）
-
-3. `useAIWriting.ts` 的 `handleEvent`：加新 case 处理状态更新
-
-4. 组件层：根据需要在时间线 / 干预卡 / 流式视图里渲染
-
-### 修改一个流式打字机的行为
-
-每个 streaming view 内部都是独立的：
-- 状态在 `useAIWriting.ts` 的 `streaming*` 系列字段
-- 渲染在 `*StreamingView.tsx`
-- 流式 chunk 处理在 `handleEvent` 的 `outline_chunk` / `draft_chunk` / `review_chunk` 分支
-
-### 新增草稿到右侧画布的逻辑
-
-`AIWritingPanel.tsx` 里 `useEffect` 监听 `state.currentDraftMarkdown` → 调 `setArtifact` 更新右侧 `CanvasGraphContext`。如果需要新的 artifact 类型，看 `contexts/CanvasGraphContext.tsx` 的 artifact 接口。
-
----
-
-## 九、容错与边界处理
-
-### 已落实的容错（不会阻断写作）
-- ✅ `saveAIWritingTranscript` 失败仅 `console.warn`
-- ✅ 历史会话列表加载失败仅 `console.warn`
-- ✅ 重命名/删除会话失败静默吞掉
-- ✅ 后端 SSE 推 `notice` / `error` 事件时，前端只渲染不中断
-- ✅ JSON parse 失败时 SSE 帧被静默丢弃（不影响后续帧）
-
-### 已知边界（可能影响 UI 体验）
-- ⚠️ **SSE 断线无自动重连** — 网络抖动 / 反代超时后用户需要手动刷新
-- ⚠️ **多 worker 部署下 SSE 事件丢失**（详见 `ai-writing-说明.md`）—— 前端只能感知到「卡住」，没有重连恢复机制
-- ⚠️ `outline_chunk` / `draft_chunk` / `review_chunk` 的 `text` / `is_thinking` 字段是 snake_case，前端类型是 `text` / `isThinking` 但 normalize 时是**保留 snake_case 直接读**（参考 `useAIWriting.ts` 的 `(event as unknown as { text: string }).text`），这是历史包袱，未来 normalize 函数应统一处理
-
----
-
-## 十、调试技巧
-
-### 看 SSE 原始事件
-浏览器 DevTools → Network → 找 `/api/ai-writing/<id>/stream` 请求 → Response（注意是 EventStream 格式，不能直接展开 JSON）。
-
-### 查当前 hook 状态
-在浏览器 console 里：
-```js
-// 需要安装 React DevTools，在 Components tab 找到 AIWritingPanel
-// 或在 useAIWriting 里临时加：
-useEffect(() => { (window as any).__aiwriting = state; }, [state]);
-// 然后在 console 里 __aiwriting 看
-```
-
-### 模拟事件
-开发期可以注释掉 `subscribeToProgress`，手动调 `handleEvent({...})` 测试 reducer 行为。
-
-### 看后端 transcript
-```
-GET /api/ai-writing/sessions/<id>
-```
-返回里 `transcript` 字段就是前端组装过的完整时间线 JSON。
-
----
-
-## 十一、性能注意点
-
-### 大数组渲染
-- `progressEvents` 在长写作里可能上千条 → `AIWritingTimeline` 应该考虑虚拟滚动（当前未实现，会议室会议讨论过）
-- `streamingDraftSections` 章节多时也是潜在瓶颈
-
-### transcript PUT 频率
-- 当前每次 `progressEvents` 变化都会触发保存（实际上是 useEffect 监听）
-- 大量 chunk 事件会导致**每秒 N 次 PUT**，后端 MySQL 写压力大
-- **优化建议**：在 `useAIWriting.ts` 给 saveAIWritingTranscript 加 debounce（1-2 秒），或者只在 `await_user` / `done` / `error` 关键节点保存
-
-### 浏览器内存
-- progressEvents 不主动清理 → 长会话可能占用几十 MB
-- 完成一篇文章后建议 `reset()` 清空状态
-
----
-
-## 十二、相关后端接口（速查）
-
-| 接口 | 用途 | 前端调用方 |
-|---|---|---|
-| `POST /api/ai-writing/start` | 启动写作 | `startWritingSession` |
-| `GET /api/ai-writing/{id}/stream` | SSE 进度流 | `subscribeToProgress` |
-| `POST /api/ai-writing/{id}/resume` | 提交干预 | `resumeWriting` |
-| `GET /api/ai-writing/{id}/state` | 查 graph 状态快照（调试用） | 暂未调用 |
-| `GET /api/ai-writing/sessions` | 历史列表 | `listAIWritingSessions` |
-| `GET /api/ai-writing/sessions/{id}` | 历史详情 | `getAIWritingSession` |
-| `PATCH /api/ai-writing/sessions/{id}` | 重命名 | `renameAIWritingSession` |
-| `DELETE /api/ai-writing/sessions/{id}` | 删除会话 | `deleteAIWritingSession` |
-| `PUT /api/ai-writing/sessions/{id}/transcript` | 保存时间线（fire-and-forget） | `saveAIWritingTranscript` |
-| `GET /api/ai-writing/article-types` | 文章类型下拉 | `listArticleTypes` |
-| `POST /api/ai-writing/admin/cleanup` | admin 手动清理 | 暂未在 UI 暴露 |
-
----
-
-## 十三、未来优化方向
-
-| 项目 | 说明 | 工作量 |
-|---|---|---|
-| transcript PUT 防抖 | 减少 MySQL 写压力 | 1 小时 |
-| SSE 自动重连 | 网络抖动 / 反代超时后能恢复 | 0.5 天 |
-| 时间线虚拟滚动 | 处理超长 progressEvents | 0.5 天 |
-| 干预卡组件解耦 | 663 行的 InterventionCard 拆成 5 个独立卡片 | 1 天 |
-| AbortController 串行化 | 避免重启写作时旧 SSE 还没断 | 0.5 天 |
-| 后端字段统一 camelCase | 消除 snake_case ↔ camelCase 转换层 | 需后端配合 |
-
----
-
-## 附录 A：所有类型一览
-
-完整定义在 `types/ai-writing.ts`，主要类型：
-
-```typescript
-// 业务实体
-AIMaterial            // 单个素材
-AIOutline             // 大纲
-OutlineSection        // 大纲单章节
-ReviewIssue           // 审核问题
-ReviewResult          // 完整审核结果
-BlockedSection        // 素材不足的章节
-SectionDecision       // 章节求助决策
-
-// 流程
-WritingStatus         // 13 种状态
-ProgressEventType     // 17 种事件类型
-ProgressEvent         // SSE 事件载荷
-UserInterventionPayload  // 干预提交体
-AIWritingRequest      // 启动写作的请求
-CompletedIntervention // 已完成的干预记录
-
-// 流式视图
-StreamingDraftSection
-StreamingReviewItem
-RevisionSummary
-
-// Hook 状态
-AIWritingState        // useAIWriting 的完整状态
-```
-
----
-
-## 附录 B：常见踩坑
-
-| 现象 | 原因 | 解决 |
-|---|---|---|
-| 前端类型 camelCase 但拿到 undefined | 后端 snake_case 没 normalize | 在 `api/ai-writing.ts` 的 normalize 函数里加字段 |
-| 进度卡住不动 | SSE 断了或落到错的 worker | 刷新页面，看 `ai-writing-说明.md` 多 worker 部分 |
-| 历史会话回显时间线缺失 | transcript 保存失败 | DB 列容量 / 后端日志查 `save_transcript` |
-| 修改大纲后没生效 | 用户 PATCH editedOutline 但没勾选 confirm | InterventionCard 大纲分支检查 action 字段 |
-| 草稿渲染换行错乱 | LLM 输出包含奇怪 markdown | `DraftStreamingView` 里 markdown parser 设置 |
-
----
-
-如需补充内容，请直接编辑本文件，并在 git commit message 里注明改动原因。

frontend-web/docs/ai-writing-frontend-refactor-checklist.md

@@ -1,472 +0,0 @@
-# AI 写作前端改造清单
-
-## 1. 目标
-
-在不新增第二套页面的前提下，基于现有 `open-canvas` 页面，把左侧从“单轮聊天输入框”升级为“多 Agent 写作工作台”，右侧继续沿用当前 `artifact` 编辑与流式预览能力。
-
-当前核心文件：
-
-- [CanvasResizableLayout.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/layout/CanvasResizableLayout.tsx)
-- [CanvasChatPanel.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/chat/CanvasChatPanel.tsx)
-- [CanvasArtifactPanel.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/artifact/CanvasArtifactPanel.tsx)
-- [CanvasGraphContext.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/contexts/CanvasGraphContext.tsx)
-- [CanvasStreamContext.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/contexts/CanvasStreamContext.tsx)
-- [useCanvasThreadStream.ts](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/hooks/useCanvasThreadStream.ts)
-- [runs.ts](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/api/runs.ts)
-
----
-
-## 2. 改造原则
-
-- 不改右侧主编辑器交互心智
-- 不复制新页面
-- 不破坏现有普通 chat 模式
-- 新增“写作工作流模式”时尽量以增量状态字段和新组件完成
-- 所有 workflow 能力都应允许逐步灰度
-
----
-
-## 3. 推荐前端结构
-
-建议在 `frontend-web/src/open-canvas` 下新增以下目录：
-
-```text
-frontend-web/src/open-canvas/
-  workflow/
-    api/
-      writing-workflow.ts
-    components/
-      WritingWorkflowEntryForm.tsx
-      WritingWorkflowTimeline.tsx
-      WritingWorkflowEventList.tsx
-      WritingWorkflowArtifactDrawer.tsx
-      WritingWorkflowConfirmCard.tsx
-      WritingWorkflowHeader.tsx
-    contexts/
-      WritingWorkflowContext.tsx
-    hooks/
-      useWritingWorkflow.ts
-      useWritingWorkflowEvents.ts
-    types/
-      workflow.ts
-    utils/
-      workflow-event.ts
-```
-
-说明：
-
-- `open-canvas` 原有聊天、artifact、editor 目录不重构
-- 以 `workflow/` 作为新能力边界，减少对既有文件的侵入
-
----
-
-## 4. 状态设计
-
-## 4.1 新增的核心状态
-
-建议新增：
-
-- `workflowMode: "chat" | "writing_pipeline"`
-- `workflowRunId: string | null`
-- `workflowStage`
-- `workflowStatus: "idle" | "running" | "waiting_user" | "completed" | "failed"`
-- `workflowEvents: WritingWorkflowEvent[]`
-- `workflowArtifacts: WritingWorkflowArtifact[]`
-- `workflowPendingAction: WritingPendingAction | null`
-
-## 4.2 推荐类型定义
-
-建议在 `workflow/types/workflow.ts` 中先定义：
-
-```ts
-export type WritingWorkflowStage =
-  | "idle"
-  | "collecting_materials"
-  | "generating_outline"
-  | "await_outline_confirmation"
-  | "writing_draft"
-  | "reviewing_draft"
-  | "rewriting_draft"
-  | "completed"
-  | "failed";
-
-export type WritingWorkflowEventType =
-  | "workflow_started"
-  | "stage_changed"
-  | "agent_started"
-  | "agent_output_chunk"
-  | "artifact_generated"
-  | "human_confirmation_required"
-  | "retry_scheduled"
-  | "workflow_completed"
-  | "workflow_failed";
-```
-
-第一版把类型先收紧，后续再扩展。
-
----
-
-## 5. 组件拆分建议
-
-## 5.1 左侧主面板改造
-
-当前 `CanvasChatPanel` 建议只承担“模式路由”和布局容器职责，不继续无限堆逻辑。
-
-建议改造为：
-
-- `chat` 模式继续渲染现有消息列表 + 输入框
-- `writing_pipeline` 模式渲染新的工作流视图
-
-建议拆分出：
-
-- `CanvasChatConversation.tsx`
-- `CanvasChatInputBox.tsx`
-- `CanvasWorkflowPanel.tsx`
-
-这样后续不会把 `CanvasChatPanel.tsx` 变成一个过大的组件。
-
-## 5.2 新增组件职责
-
-### `WritingWorkflowEntryForm.tsx`
-
-负责采集：
-
-- 主题
-- 文章类型
-- 目标读者
-- 语气风格
-- 目标篇幅
-- 是否需要引用资料
-- 禁写项
-- 补充说明
-
-### `WritingWorkflowTimeline.tsx`
-
-负责显示阶段：
-
-- 研究中
-- 提纲生成中
-- 等待确认提纲
-- 正在写初稿
-- 正在审稿
-- 正在重写
-- 已完成
-
-### `WritingWorkflowEventList.tsx`
-
-负责显示细粒度事件：
-
-- 哪个 Agent 开始执行
-- 当前在处理哪一步
-- 当前产生了什么中间结果
-- 是否重试
-
-### `WritingWorkflowArtifactDrawer.tsx`
-
-负责展示中间产物：
-
-- 素材卡片
-- 提纲
-- 初稿
-- 编辑意见
-- 重写稿
-
-### `WritingWorkflowConfirmCard.tsx`
-
-负责展示用户确认点：
-
-- 确认提纲
-- 驳回提纲并附带修改意见
-- 继续写稿
-- 指定重写章节
-
----
-
-## 6. Context 与 Hook 改造建议
-
-## 6.1 `CanvasGraphContext`
-
-当前它只维护：
-
-- `messages`
-- `artifact`
-- `streamingArtifact`
-- `isStreaming`
-
-建议不要把 workflow 状态直接塞进现有 `CanvasGraphContext`，否则会让语义过重。
-
-推荐做法：
-
-- 保留 `CanvasGraphContext` 继续服务右侧 artifact 和通用流式状态
-- 新增 `WritingWorkflowContext`
-
-## 6.2 `WritingWorkflowContext`
-
-建议承载：
-
-- 当前 workflow 运行状态
-- 中间产物列表
-- 待确认操作
-- workflow 事件缓存
-- 启动 / 取消 / 确认 / 重写等 action
-
-## 6.3 `useCanvasThreadStream`
-
-当前这个 hook 已经负责：
-
-- 创建 thread
-- 提交消息
-- 接收 thread stream
-- 将 `update_artifact` 同步到右侧
-
-建议不要把“多 Agent workflow 状态机”也硬塞进去。
-
-推荐方案：
-
-- 保留 `useCanvasThreadStream` 给普通 chat 或兼容旧能力使用
-- 新增 `useWritingWorkflow`
-- 新增 `useWritingWorkflowEvents`
-
-分工如下：
-
-- `useCanvasThreadStream`：普通对话流
-- `useWritingWorkflow`：创建 workflow、提交表单、触发确认动作
-- `useWritingWorkflowEvents`：订阅 workflow 事件流
-
----
-
-## 7. API 接入建议
-
-## 7.1 前端 API 文件
-
-新增：
-
-- `workflow/api/writing-workflow.ts`
-
-建议暴露方法：
-
-- `createWorkflow(payload)`
-- `startWorkflow(id)`
-- `getWorkflow(id)`
-- `subscribeWorkflowEvents(id, handlers)`
-- `confirmOutline(id, payload)`
-- `rewriteSection(id, payload)`
-- `approveFinal(id)`
-
-## 7.2 事件流形式
-
-优先级建议：
-
-1. `SSE`
-2. 流式 HTTP chunk
-3. 轮询兜底
-
-理由：
-
-- 事件驱动比整段消息流更适合 workflow UI
-- 可以更方便映射到时间线和事件列表
-
----
-
-## 8. 与右侧 Artifact 的衔接
-
-## 8.1 现有优势
-
-当前 `CanvasArtifactPanel` 已具备：
-
-- 流式展示内容
-- 最终 artifact 渲染
-- 右侧编辑体验成熟
-
-这意味着多 Agent 工作流不需要再做第二套文章渲染，只要把最终阶段结果推成 artifact 即可。
-
-## 8.2 建议接法
-
-工作流各阶段结果按两类处理：
-
-- 中间产物：进入左侧 `workflowArtifacts`
-- 可阅读正文：同步一份到右侧 `artifact`
-
-推荐映射：
-
-- 提纲：可选同步到右侧，供用户预览
-- 初稿：同步到右侧
-- 重写稿：覆盖或新增版本到右侧
-- 终稿：作为最终右侧主版本
-
-## 8.3 版本策略
-
-建议右侧版本保留：
-
-- `outline`
-- `draft_v1`
-- `draft_v2`
-- `final`
-
-如果现有 artifact 数据结构不方便承载完整版本树，第一版可先保留在 workflowArtifacts 中，右侧只展示当前激活版本。
-
----
-
-## 9. 页面交互流程
-
-## 9.1 用户首次进入
-
-- 默认仍是现有 chat 模式
-- 在左侧增加一个显眼切换入口：`普通对话` / `写作工作流`
-
-## 9.2 启动写作工作流
-
-- 用户填写写作任务表单
-- 点击“开始生成”
-- 左侧切换到时间线 + 事件流视图
-- 右侧进入 loading 或素材 / 提纲预览态
-
-## 9.3 等待提纲确认
-
-- 时间线停在 `await_outline_confirmation`
-- 左侧出现确认卡片
-- 用户可执行：
-  - 通过提纲
-  - 要求调整提纲
-  - 追加要求
-
-## 9.4 生成初稿与审稿
-
-- 左侧显示 Agent 事件
-- 右侧展示初稿内容
-- 审稿意见在左侧展示，同时高亮需要重写的章节
-
-## 9.5 完成
-
-- 左侧显示“终稿已完成”
-- 右侧进入可继续局部 AI 编辑状态
-
----
-
-## 10. 分步开发清单
-
-## Step 1：类型与假数据
-
-目标：
-
-- 先把 workflow 的类型、mock 数据、组件骨架搭好
-
-任务：
-
-- 新建 `workflow/types/workflow.ts`
-- 新建 `workflow/components/*`
-- 用本地 mock 事件驱动时间线和事件流
-
-验收：
-
-- 不接后端也能在页面中演示完整流程
-
-## Step 2：模式切换
-
-目标：
-
-- 在 `CanvasChatPanel` 中接入 `chat / writing_pipeline` 双模式
-
-任务：
-
-- 拆出 `CanvasWorkflowPanel`
-- 增加模式切换 UI
-- 保证旧 chat 不回归
-
-验收：
-
-- 现有功能不受影响
-- 新模式可进入表单页
-
-## Step 3：接入 workflow API
-
-目标：
-
-- 从 mock 切到真实 API
-
-任务：
-
-- 接 `create/start/get/events`
-- 实现基础错误态和重试态
-
-验收：
-
-- 前后端可联调跑一条主链路
-
-## Step 4：接入确认节点
-
-目标：
-
-- 支持提纲确认和指定章节重写
-
-任务：
-
-- 做确认卡片
-- 做动作回传
-
-验收：
-
-- 用户能在流程中介入
-
-## Step 5：打通右侧版本
-
-目标：
-
-- 让 workflow 产物稳定进入右侧编辑器
-
-任务：
-
-- 约定 artifact 映射
-- 接入版本切换或当前版本覆盖
-
-验收：
-
-- 终稿稳定显示在右侧
-
----
-
-## 11. 建议修改点位
-
-优先涉及文件：
-
-- [CanvasChatPanel.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/chat/CanvasChatPanel.tsx)
-- [CanvasGraphContext.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/contexts/CanvasGraphContext.tsx)
-- [useCanvasThreadStream.ts](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/hooks/useCanvasThreadStream.ts)
-- [CanvasArtifactPanel.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/artifact/CanvasArtifactPanel.tsx)
-
-建议新增，不建议重写原有：
-
-- `open-canvas/workflow/api/writing-workflow.ts`
-- `open-canvas/workflow/contexts/WritingWorkflowContext.tsx`
-- `open-canvas/workflow/hooks/useWritingWorkflow.ts`
-- `open-canvas/workflow/hooks/useWritingWorkflowEvents.ts`
-- `open-canvas/workflow/components/*`
-
----
-
-## 12. 联调约定
-
-前后端需要尽早统一：
-
-- workflow id 命名
-- stage 枚举
-- event type 枚举
-- artifact type 枚举
-- user action payload
-- 错误码与可恢复动作
-
-建议先由前端与后端共同确认一份 `workflow.ts` 契约文档，再开工。
-
----
-
-## 13. 最终建议
-
-前端最重要的不是“把 Agent 结果展示出来”，而是把“工作流过程可视化并允许人工介入”做清楚。
-
-第一版建议先保证三件事：
-
-1. 左侧能看见阶段进展
-2. 用户能确认提纲
-3. 右侧能稳定收到初稿和终稿
-
-只要这三件事稳定，后续再继续加章节重写、评分展示、素材卡片增强，风险会小很多。

frontend-web/docs/ai-writing-weak-model-multi-agent-prd.md

@@ -1,718 +0,0 @@
-# AI 写作弱模型多 Agent 编排需求文档
-
-## 1. 背景与目标
-
-当前 `open-canvas` 页面右侧的成品展示与编辑体验已经比较成熟，但左侧模型直接生成文章的质量还不稳定。对于内网部署的弱性能大模型，单轮直出通常会出现以下问题：
-
-- 结构松散，长文容易跑题
-- 素材不足，内容空泛
-- 事实依据弱，容易幻觉
-- 润色能力有限，语言风格不统一
-- 一次生成失败后缺少可控的纠偏机制
-
-因此本次需求的核心目标不是继续优化“单个模型一次写完”，而是在内网用代码编排一个“小型杂志社工作流”，让弱模型通过多角色分工协作，产出明显优于单模型直出的文章质量。
-
-建议的角色分工：
-
-- `Agent A 研究员`：负责搜集内网素材、归纳事实、提取观点
-- `Agent B 作家`：基于选题、素材和结构写初稿
-- `Agent C 严苛编辑`：负责挑错、质检、润色、打回重写
-- `Supervisor / Orchestrator`：负责流程调度、状态记录、重试与终止判断
-
----
-
-## 2. 本次建设边界
-
-### 2.1 前端边界
-
-前端继续使用现有 `open-canvas` 页面，不新开第二套编辑器页面。
-
-当前相关入口：
-
-- [CanvasResizableLayout.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/layout/CanvasResizableLayout.tsx)
-- [CanvasChatPanel.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/chat/CanvasChatPanel.tsx)
-- [CanvasArtifactPanel.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/components/artifact/CanvasArtifactPanel.tsx)
-- [CanvasStreamContext.tsx](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/contexts/CanvasStreamContext.tsx)
-- [runs.ts](/F:/react/deeflow-code/deerflow-server-master/frontend-web/src/open-canvas/api/runs.ts)
-
-前端本期只做以下增强：
-
-- 在左侧聊天区增加“写作工作流模式”
-- 让用户能看到多 Agent 阶段进度，而不是只看到最终回答
-- 支持结构化输入：主题、体裁、目标读者、篇幅、语气、参考资料、禁写项
-- 支持查看中间产物：提纲、素材卡片、初稿、编辑意见、终稿
-- 支持人工介入：确认提纲、确认初稿、接受编辑建议、手动重跑某一步
-
-### 2.2 后端边界
-
-后端必须单开新路线，不影响其他同事当前功能开发。
-
-建议原则：
-
-- 不直接改现有 DeerFlow 主流程
-- 不把多 Agent 逻辑硬塞进当前通用对话链路
-- 以独立服务或独立模块形式建设
-- 通过清晰 API 与当前前端页面对接
-
-推荐落地位置：
-
-- 基于仓库中的 `offline-backend-20260512` 单独开一条 `ai-writing-orchestrator` 路线
-- 或在后端新建独立目录，例如 `offline-backend-20260512/apps/ai_writing_orchestrator`
-
----
-
-## 3. 为什么多 Agent 对弱模型更合适
-
-弱模型最怕“一个 prompt 做完所有事”，因为这要求模型同时完成：
-
-- 选题理解
-- 信息检索
-- 信息筛选
-- 结构规划
-- 长文写作
-- 自我校验
-- 风格润色
-
-把这些任务拆开后，每个 Agent 只处理一个更短、更清晰、更容易被弱模型完成的子任务，通常会带来以下收益：
-
-- 降低单次上下文复杂度
-- 降低一次性长输出失败率
-- 把“写得不好”变成“某一步做得不好”，便于重试
-- 可以在关键节点插入规则校验与人工确认
-- 可以用程序补足模型短板，而不是完全依赖模型智力
-
-这套方案的本质不是“让模型变聪明”，而是“让系统更会组织模型工作”。
-
----
-
-## 4. 可借鉴的开源项目
-
-以下项目适合借鉴，但不建议整套照搬。建议以“借鉴状态机、角色协作、阶段拆分、重试与审稿机制”为主。
-
-### 4.1 第一优先级：LangGraph
-
-推荐原因：
-
-- 天然适合把写作流程建模成状态图
-- 支持多步骤、条件分支、重试、人工介入
-- 便于把“研究 -> 提纲 -> 初稿 -> 评审 -> 重写”固化成可控流程
-- 对“弱模型 + 强流程控制”很友好
-
-可借鉴点：
-
-- `StateGraph` 的状态驱动编排
-- 每一步单独定义输入、输出、失败处理
-- 可视化地表达“通过 / 打回 / 重试 / 终止”
-
-参考：
-
-- [langchain-ai/langgraph](https://github.com/langchain-ai/langgraph)
-- [langgraph supervisor pattern](https://github.com/langchain-ai/langgraph-supervisor-py)
-
-### 4.2 第二优先级：STORM
-
-推荐原因：
-
-- 它本身就是“研究 + 提纲 + 成文 + 打磨”的长文系统
-- 对“先研究后写作”的思路非常契合
-- 很适合借鉴其“问题驱动研究”和“分阶段生成”的思想
-
-根据其 GitHub README，STORM 将长文生成拆成两个大阶段：先研究并产出提纲，再基于提纲与资料写长文；其引擎进一步拆成知识整理、提纲生成、正文生成、文章润色四个模块。
-
-这和我们的目标高度一致，尤其适合借鉴：
-
-- 提纲先行
-- 素材引用先行
-- 分模块写作
-- 后置润色
-
-参考：
-
-- [stanford-oval/storm](https://github.com/stanford-oval/storm)
-
-### 4.3 第三优先级：Deep Research Agent
-
-推荐原因：
-
-- 明确支持本地模型与云模型混用
-- 已经包含研究、写作、质量校验、缓存、重试等能力
-- 很适合借鉴“研究阶段如何约束弱模型”
-
-根据其 README，这个项目采用四个专职 Agent，并且带有可信度评分、质量验证、重试逻辑、缓存和 checkpoint。
-
-特别适合借鉴：
-
-- 素材缓存
-- 分阶段质量评分
-- 节点失败重试
-- 研究结果结构化存储
-
-参考：
-
-- [tarun7r/deep-research-agent](https://github.com/tarun7r/deep-research-agent)
-
-### 4.4 可选借鉴：CrewAI
-
-推荐原因：
-
-- 角色扮演表达自然
-- 写“研究员 / 作家 / 编辑”这种协作关系很直观
-- Flow + Crew 的组织方式适合做 demo 和快速验证
-
-不建议作为首选底座的原因：
-
-- 更偏“Agent 角色编排体验”
-- 若要做企业内网稳定落地，状态管理和流程可控性通常不如 LangGraph 路线清晰
-
-适合借鉴：
-
-- 角色定义写法
-- Task 模板
-- 多角色协作 prompt 结构
-
-参考：
-
-- [crewAIInc/crewAI](https://github.com/crewAIInc/crewAI)
-
-### 4.5 不建议新项目优先采用：AutoGen
-
-原因：
-
-- 截至最近公开信息，`microsoft/autogen` 已进入 maintenance mode
-- 官方建议新项目优先采用 `Microsoft Agent Framework`
-
-如果要借鉴，只建议借鉴早期多 Agent 对话模式，不建议作为本项目主框架。
-
-参考：
-
-- [microsoft/autogen](https://github.com/microsoft/autogen)
-- [microsoft/agent-framework](https://github.com/microsoft/agent-framework)
-
-### 4.6 结论
-
-综合本项目需求，建议技术选型优先级如下：
-
-1. `LangGraph` 作为主编排框架
-2. `STORM` 借鉴研究-提纲-成文-润色的模块划分
-3. `Deep Research Agent` 借鉴缓存、评分、重试、可观测性
-4. `CrewAI` 借鉴角色 prompt 设计与任务模板
-
----
-
-## 5. 目标产品形态
-
-用户在当前 `open-canvas` 页面中，不再只是“向模型提问写文章”，而是启动一个可视化的写作流水线。
-
-理想交互流程：
-
-1. 用户输入主题、用途、风格、读者、篇幅要求
-2. 系统先进入“研究阶段”
-3. 系统给出资料卡片与候选提纲
-4. 用户确认提纲或调整
-5. 系统生成初稿
-6. 严苛编辑给出问题清单
-7. 系统自动重写问题段落
-8. 系统输出终稿到右侧编辑区
-9. 用户可继续局部改写、扩写、精简
-
-核心体验目标：
-
-- 左侧像“编辑部工作台”
-- 右侧像“成文编辑器”
-- 用户知道系统现在进行到哪一步
-- 用户可以在关键节点接管，而不是只能等待最终结果
-
----
-
-## 6. 多 Agent 流程设计
-
-## 6.1 建议的最小可用流程 MVP
-
-第一版不要一上来做很复杂，建议先做 4 步闭环：
-
-1. `Research`
-   - 输入：主题、用户要求、内网资料源
-   - 输出：素材卡片列表、可引用事实列表、风险点列表
-
-2. `Outline`
-   - 输入：用户要求 + 素材卡片
-   - 输出：结构化提纲
-
-3. `Draft`
-   - 输入：提纲 + 素材卡片
-   - 输出：初稿
-
-4. `ReviewAndRewrite`
-   - 输入：初稿 + 用户要求 + 素材卡片
-   - 输出：问题清单、改写稿、终稿
-
-MVP 终止条件：
-
-- 编辑评分达标则结束
-- 不达标最多重写 2 次
-- 超过次数则返回“需要人工介入”
-
-## 6.2 第二阶段增强流程
-
-在 MVP 跑通后，再增加：
-
-- `Planner`：根据文章类型动态规划流程
-- `SectionWriter`：按章节分别写作，避免长文崩坏
-- `FactChecker`：逐段核对素材来源
-- `StyleEditor`：统一语气、标题风格、句式节奏
-- `ComplianceReviewer`：内网场景下做敏感词、保密、术语规范检查
-
-## 6.3 建议的状态机
-
-建议将流程状态固定为：
-
-- `idle`
-- `collecting_materials`
-- `generating_outline`
-- `await_outline_confirmation`
-- `writing_draft`
-- `reviewing_draft`
-- `rewriting_draft`
-- `completed`
-- `failed`
-- `human_intervention_required`
-
-这样前端和后端都可以围绕统一状态通信。
-
----
-
-## 7. Agent 角色定义建议
-
-## 7.1 Agent A 研究员
-
-职责：
-
-- 搜集内网知识库、文档库、FAQ、历史稿件中的相关信息
-- 输出结构化素材，而不是长篇自然语言
-- 对每条素材标注来源、可信度、适用角度
-
-输出格式建议：
-
-- `facts[]`
-- `quotes[]`
-- `examples[]`
-- `risks[]`
-- `source_refs[]`
-
-约束建议：
-
-- 禁止直接生成整篇文章
-- 不做风格化表达
-- 每条结论必须可回溯到来源
-
-## 7.2 Agent B 作家
-
-职责：
-
-- 严格基于提纲和素材写稿
-- 按章节写，而不是一次写完整篇
-- 对每段附带素材引用 ID，便于后续审核
-
-约束建议：
-
-- 无素材不发挥
-- 每段只服务一个小节目标
-- 段落长度控制
-- 输出结构化草稿数据，而不仅是纯文本
-
-## 7.3 Agent C 严苛编辑
-
-职责：
-
-- 检查逻辑跳跃、素材不足、事实不稳、表述空泛、风格不统一
-- 输出明确的“问题清单”和“改写指令”
-- 必要时打回指定章节，而不是整篇推翻
-
-输出格式建议：
-
-- `issues[]`
-- `severity`
-- `rewrite_instructions[]`
-- `accept/reject`
-
-编辑原则建议：
-
-- 优先挑事实问题，再挑结构问题，最后才是文风问题
-- 问题描述必须可执行，不能只说“写得不够好”
-
-## 7.4 Supervisor
-
-职责：
-
-- 负责流程启动、状态流转、失败重试、记录日志
-- 判断是否需要回到上一步
-- 控制最大重试次数
-- 对外提供统一 API 与流式事件
-
----
-
-## 8. 前端需求
-
-## 8.1 保持当前页面结构不变
-
-继续沿用当前左右布局：
-
-- 左侧：聊天 + 流程进度 + 中间产物
-- 右侧：最终文章编辑与局部 AI 改写
-
-不建议再复制一套新页面，以免造成维护分叉。
-
-## 8.2 左侧新增 UI 模块
-
-建议在 `CanvasChatPanel` 基础上新增：
-
-- 写作任务表单
-- 工作流阶段时间线
-- Agent 执行日志面板
-- 中间产物抽屉
-- 人工确认卡片
-
-建议新增的前端概念：
-
-- `workflowMode`: `chat | writing_pipeline`
-- `workflowStage`
-- `workflowRunId`
-- `workflowEvents[]`
-- `workflowArtifacts[]`
-
-## 8.3 需要展示的中间产物
-
-至少支持展示：
-
-- 素材卡片
-- 提纲
-- 初稿
-- 编辑问题单
-- 重写结果
-- 最终定稿
-
-这些内容建议不仅显示在消息区，也保存到右侧可选版本中，便于回看。
-
-## 8.4 人工介入节点
-
-至少提供两个确认点：
-
-- 提纲确认
-- 初稿确认或编辑后重跑
-
-后续可扩展：
-
-- 指定重写某个章节
-- 锁定某段不允许再改
-- 替换某条素材后重新生成
-
----
-
-## 9. 后端需求
-
-## 9.1 架构原则
-
-后端新路线必须满足：
-
-- 与现有通用对话链路解耦
-- 与现有 Agent 运行时解耦
-- 独立维护 Prompt、状态机、数据结构
-- 可以单独部署、单独回滚、单独压测
-
-## 9.2 推荐模块划分
-
-建议后端拆分为以下模块：
-
-- `workflow_orchestrator`
-- `agent_registry`
-- `material_retriever`
-- `outline_generator`
-- `draft_writer`
-- `editor_reviewer`
-- `rewrite_engine`
-- `workflow_store`
-- `stream_event_adapter`
-
-## 9.3 API 建议
-
-建议最小 API：
-
-- `POST /api/ai-writing/workflows`
-  - 创建写作任务
-
-- `POST /api/ai-writing/workflows/{id}/start`
-  - 启动流程
-
-- `GET /api/ai-writing/workflows/{id}`
-  - 查询当前状态
-
-- `GET /api/ai-writing/workflows/{id}/events`
-  - 获取事件流或轮询事件
-
-- `POST /api/ai-writing/workflows/{id}/confirm-outline`
-  - 用户确认提纲
-
-- `POST /api/ai-writing/workflows/{id}/rewrite-section`
-  - 指定章节重写
-
-- `POST /api/ai-writing/workflows/{id}/approve-final`
-  - 确认终稿
-
-## 9.4 流式事件建议
-
-为了与当前 `CanvasStreamContext` 风格兼容，建议后端输出结构化事件流，例如：
-
-- `workflow_started`
-- `stage_changed`
-- `agent_started`
-- `agent_output_chunk`
-- `artifact_generated`
-- `human_confirmation_required`
-- `retry_scheduled`
-- `workflow_completed`
-- `workflow_failed`
-
-前端只要订阅事件，就能把左侧工作台做出来。
-
----
-
-## 10. 弱模型优化策略
-
-这是本项目成功的关键，不能只靠“多 Agent”这四个字。
-
-## 10.1 强约束输出格式
-
-每个 Agent 尽量输出 JSON 或结构化对象，不要自由发挥。
-
-原因：
-
-- 便于程序消费
-- 便于后续 Agent 接续
-- 便于失败重试
-- 便于质量评估
-
-## 10.2 长文拆成章节生成
-
-不要让弱模型一次生成整篇长文，建议：
-
-- 先出提纲
-- 再按章节逐段写
-- 最后统一润色
-
-## 10.3 把检索和写作分离
-
-研究员只负责找资料，作家只负责组织表达。不要让写作 Agent 同时去“边搜边编”。
-
-## 10.4 程序兜底而不是模型兜底
-
-程序需要承担：
-
-- 去重
-- 引用格式化
-- 章节拼接
-- 长度控制
-- 评分阈值判断
-- 重试路由
-
-## 10.5 小步快跑、失败可回退
-
-每步都要能独立失败、独立重试、独立回放。
-
-## 10.6 引入可量化评分
-
-编辑 Agent 输出不能只是一段文字，建议给出评分维度：
-
-- 相关性
-- 事实性
-- 结构完整度
-- 语言流畅度
-- 风格一致性
-
-系统据此决定是否进入下一步。
-
----
-
-## 11. 分阶段实施计划
-
-## Phase 1：需求冻结与技术验证
-
-目标：
-
-- 确认文章类型范围
-- 确认内网资料来源
-- 选定主框架
-- 跑通最小多 Agent demo
-
-交付物：
-
-- 技术选型说明
-- 角色与状态机设计
-- 1 个主题的端到端 demo
-
-验收标准：
-
-- 弱模型可完成“研究 -> 提纲 -> 初稿 -> 编辑 -> 重写”闭环
-
-## Phase 2：后端新路线搭建
-
-目标：
-
-- 建立独立 orchestrator
-- 建立 workflow state store
-- 建立事件流输出
-- 建立可配置 prompt 模板
-
-交付物：
-
-- 独立服务目录
-- 基础 API
-- 状态机运行骨架
-
-验收标准：
-
-- 不依赖现有主流程改造即可独立跑通
-
-## Phase 3：前端接入当前页面
-
-目标：
-
-- 在 `CanvasChatPanel` 接入工作流模式
-- 增加阶段展示与人工确认
-- 中间产物可视化
-
-交付物：
-
-- 左侧工作流时间线
-- 中间产物展示面板
-- 流程控制按钮
-
-验收标准：
-
-- 用户可以在当前页面完成一次全流程写作
-
-## Phase 4：质量优化
-
-目标：
-
-- 强化素材检索质量
-- 提高提纲质量
-- 引入章节级重写
-- 引入评分与回退机制
-
-交付物：
-
-- 质量评估规则
-- 重试策略
-- Prompt 调优包
-
-验收标准：
-
-- 弱模型效果明显优于单轮直出
-
-## Phase 5：生产化
-
-目标：
-
-- 加缓存
-- 加日志
-- 加监控
-- 加失败告警
-- 加审计记录
-
-交付物：
-
-- 可观测性方案
-- 运行日志与回放
-- 配置中心或 prompt 管理机制
-
-验收标准：
-
-- 可长期维护并可定位问题
-
----
-
-## 12. 团队协作与隔离方案
-
-为了不影响其他同事，建议采用以下协作原则：
-
-- 新后端目录独立开发
-- 新接口使用独立路由前缀
-- 前端只在 `open-canvas` 内增量开发
-- 不修改现有公共线程协议，必要时增加新事件类型
-- Prompt、Agent 配置、评分规则独立存放
-
-推荐分工：
-
-- 前端 1 人：负责左侧工作流 UI 与右侧版本接入
-- 后端 1-2 人：负责 orchestrator、Agent 执行、事件流
-- 算法/Prompt 1 人：负责角色 prompt、评分规则、失败样本调优
-
----
-
-## 13. 风险与规避
-
-### 风险 1：Agent 太多，成本和耗时暴涨
-
-规避：
-
-- MVP 只保留 3 个业务 Agent + 1 个 Supervisor
-- 长文按章节写，失败只重写局部
-
-### 风险 2：弱模型在自由对话场景中失控
-
-规避：
-
-- 全流程结构化
-- 每步只做一件事
-- 强约束输入输出格式
-
-### 风险 3：内网检索质量不足，导致垃圾进垃圾出
-
-规避：
-
-- 先把资料源治理好
-- 对素材做来源、可信度、去重处理
-
-### 风险 4：前后端协议频繁变化影响联调
-
-规避：
-
-- 先定义事件模型和 artifact 模型
-- 先 mock 数据，再并行开发
-
-### 风险 5：影响现有功能稳定性
-
-规避：
-
-- 新路线、新接口、新状态机
-- 不侵入现有主链路
-
----
-
-## 14. 推荐结论
-
-本项目推荐的总体策略：
-
-1. 前端继续基于当前 `open-canvas` 页面开发，不复制新页面
-2. 后端单独开 `ai-writing-orchestrator` 新路线，避免影响现有同事
-3. 主框架优先采用 `LangGraph`
-4. 流程设计借鉴 `STORM`
-5. 质量控制借鉴 `Deep Research Agent`
-6. 角色设计与任务模板可参考 `CrewAI`
-7. 第一版只做 4 步 MVP：研究、提纲、初稿、编辑重写
-
-一句话总结：
-
-不是继续“调一个更强的 prompt”，而是把弱模型放进一个可控的编辑部流水线，让系统帮它把复杂写作拆开完成。
-
----
-
-## 15. 参考链接
-
-- [LangGraph](https://github.com/langchain-ai/langgraph)
-- [LangGraph Supervisor](https://github.com/langchain-ai/langgraph-supervisor-py)
-- [STORM](https://github.com/stanford-oval/storm)
-- [Deep Research Agent](https://github.com/tarun7r/deep-research-agent)
-- [CrewAI](https://github.com/crewAIInc/crewAI)
-- [Microsoft Agent Framework](https://github.com/microsoft/agent-framework)
-- [AutoGen](https://github.com/microsoft/autogen)

frontend-web/docs/ai-writing-优化.md

@@ -1,501 +0,0 @@
-# AI 写作 — 迁移到 LangGraph Server 的分步实现方案
-
-> **文档目的**：彻底解决 AI 写作在多 worker 部署下"SSE 时断时续 / resume 偶发 404"的根因，参照主聊天（`/workspace/chats/new`）的实现，把 AI 写作的 graph 注册成 LangGraph Server 上的一个 assistant，让 Server 接管线程、checkpoint、SSE、interrupt/resume 的全部协议。
->
-> **配套文档**：[ai-writing-说明.md](./ai-writing-说明.md) 里描述了为什么会出问题、当前已落地的兜底方案，以及方案 B/C/F 三条"绕过"路径。本文档是其中"长期方案"的具体实现路线 —— 不是绕过多 worker，而是从架构层面让它**天然不受 worker 数影响**。
->
-> **更新日期**：2026-05-20
-
----
-
-## 一、为什么走这条路
-
-主聊天和 AI 写作功能形态几乎一致（多步流式、可中断/恢复、有持久化），但**主聊天完全不受多 worker 影响**。差别在于：
-
-| 维度 | 主聊天（现状） | AI 写作（现状） | AI 写作（迁移后） |
-|---|---|---|---|
-| 前端流接入 | `useStream` (SDK) | `fetch` + 自写 `EventSource` | `useStream` (SDK) |
-| 后端运行时 | **LangGraph Server**（独立进程，端口 2024 / 经 nginx 走 `/api/langgraph`） | 嵌在 FastAPI Gateway 路由里直接跑 | **LangGraph Server**（同主聊天） |
-| 线程状态 | Server 自带持久化 checkpointer | 自管 sqlite + 一堆模块级 dict | Server 自带持久化 checkpointer |
-| SSE 通道 | Server ↔ SDK 协议层 | 自写 `asyncio.Queue` per session_id | Server ↔ SDK 协议层 |
-| 多 worker | 任何 worker 都能查 Server | per-worker 内存 dict 隔离 | 任何 worker 都能查 Server |
-| Interrupt/Resume | Server 协议（`Command(resume=...)`）| 自写 `_session_pending_pause` + `/resume` 路由 | Server 协议 |
-
-**核心收益**：迁完后 `_event_queues`、`_session_pending_pause`、`_session_repos`、`_session_user_ids`、`_session_interventions`、`_session_article_types`、`_session_error_flags`、`_session_pending_pause`、`_inflight_graph_tasks`、`_recover_session()`、自管 sqlite checkpointer 这一整套"per-process 内存状态"全部可以删掉 —— 不是"绕过"问题，是**让问题消失**。
-
-**代价**：节点要改造（流式 chunk 改走 LangGraph 原生 `StreamWriter`/state update）、前端干预卡的交互要重写、业务表写入路径要从"路由里写"挪到"节点里写"。约 **6 人日**核心改造 + 50% buffer，建议按 **9 人日**排期。
-
----
-
-## 二、现状盘点：要删 / 要留 / 要改
-
-### 2.1 要删的（迁完即可移除）
-
-| 位置 | 内容 | 备注 |
-|---|---|---|
-| `app/gateway/routers/ai_writing.py` | `POST /start`、`GET /{id}/stream`、`POST /{id}/resume`、`GET /{id}/state` | 由 LangGraph Server 的 `runs.stream / threads.create / runs.wait` 替代 |
-| 同上 | `_event_queues`、`_session_pending_pause`、`_session_model_names`、`_session_repos`、`_session_user_ids`、`_session_interventions`、`_session_error_flags`、`_session_article_types` 这 8 个模块级 dict | 状态全部交给 LangGraph Server |
-| 同上 | `_recover_session()`、`_inflight_graph_tasks`、`_spawn_graph_task()`、`wait_for_inflight_graph_tasks()` | 跨 worker 恢复 / drain 都由 Server 内建机制处理 |
-| 同上 | `_make_config()` 里注入 `sse_queue` / `sse_session_id` 的逻辑 | 流式输出改走 LangGraph 原生通道 |
-| `packages/harness/deerflow/agents/ai_writing/graph.py` | `_get_async_checkpointer()`、`get_ai_writing_checkpointer()`、`shutdown_ai_writing_graph()`、`AI_WRITING_GRAPH` 单例、`_async_checkpointer_singleton` | checkpoint 由 langgraph.json 的全局 checkpointer 接管 |
-| `app/gateway/ai_writing_cleanup.py` | "联动清理 sqlite checkpointer thread" 那一段 | 改成调 `langgraph_sdk` 的 `threads.delete()` |
-| `offline-backend-20260512/config.yaml` | `checkpointer:` 段里 AI 写作专用的 sqlite 路径（如果跟主 checkpointer 不同） | 共用主配置 |
-
-### 2.2 要保留的
-
-| 位置 | 内容 | 理由 |
-|---|---|---|
-| `packages/harness/deerflow/persistence/ai_writing_sessions/` | MySQL 业务表（标题、最终 draft、completed_interventions、transcript、article_type、status…） | 列表页 / 历史回显 / 全文搜索都依赖业务表，**不能让 LangGraph checkpoint 取代它** —— checkpoint 是流程状态，业务表是产品形态 |
-| `GET/PATCH/DELETE /api/ai-writing/sessions[/{id}]` | 列表 / 重命名 / 删除 | 只查业务表，不碰 graph |
-| `PUT /api/ai-writing/sessions/{id}/transcript` | 时间线持久化 | 维持锦上添花的回显方案 |
-| `GET/POST/PATCH/DELETE /api/ai-writing/article-types[/{id}]` | 文章类型 CRUD | 纯业务路由，跟 graph 无关 |
-| `POST /api/ai-writing/admin/cleanup` | admin 清理入口 | 路由保留，内部实现改 |
-| 4 个 interrupt 暂停点 + 5 个节点 + 全部 state 字段 | 业务逻辑零改动 | `pause_material_confirm` / `pause_outline_confirm` / `pause_section_help` / `pause_draft_confirm` / `pause_review_confirm` 用的就是 LangGraph 原生 `interrupt()`，直接吃迁移红利 |
-
-### 2.3 要改的
-
-| 位置 | 改造点 |
-|---|---|
-| `graph.py` | 删自管 checkpointer，导出 `make_ai_writing_graph(config) → CompiledStateGraph`，由 Server 注入 checkpointer |
-| `langgraph.json` | `graphs` 里增加 `"ai_writing": "deerflow.agents.ai_writing.graph:make_ai_writing_graph"` |
-| 各 node（`researcher.py` / `writer_outline.py` / `writer_draft.py` / `editor.py`） | 流式输出从 `sse_queue.put_nowait(...)` 改成 LangGraph 原生 `get_stream_writer()` 推 custom 事件 |
-| 各 node | DB 写入（草稿、审核结果、status）从「路由里调 repo」改成「节点里通过 `RunnableConfig` 拿 `thread_id` 调 repo」 |
-| 各 node | "创建 session 行"从 `/start` 路由里挪到 `intent_parser_node`（或前端 `onCreated` 回调里调一个轻量级 upsert API） |
-| `langgraph_auth.py` | 给 `ai_writing` assistant 加授权规则（保证只能访问自己的 thread） |
-| 前端 `frontend-web/src/open-canvas/` | 完全弃用现有 `api/ai-writing.ts` 的 `fetch + EventSource`，新写 `useAIWritingStream` hook（基于 `@langchain/langgraph-sdk/react` 的 `useStream`） |
-| 前端 4 个干预卡 | 提交回调从 `POST /resume` 改为 `thread.submit(new Command({ resume: payload }))` |
-| 前端"启动写作"按钮 | 从 `POST /start` + 拿 session_id + 建 EventSource 改成 `thread.submit({...args})` 触发 `onCreated` 回调 |
-| `tests/test_ai_writing_session_recovery.py` | 整体删除 —— 跨 worker 恢复由 LangGraph Server 接管，不再是 AI 写作自己的事 |
-| 新增 `tests/test_ai_writing_assistant.py` | 通过 LangGraph SDK in-process 跑一遍 graph，覆盖 interrupt / resume / custom stream / state 持久化 |
-
----
-
-## 三、分步实施
-
-### 阶段 0：可行性预演（0.5 d）
-
-**目标**：在不动现有代码的前提下，验证"把 ai_writing graph 注册到 LangGraph Server 并通过 SDK 跑通"这条路完全可行。
-
-1. 临时在 `langgraph.json` 的 `graphs` 里加一条 `"ai_writing_probe": "deerflow.agents.ai_writing.graph:build_ai_writing_graph"`（直接复用现有 `build_ai_writing_graph`，不传 checkpointer 让 Server 注入）。
-2. 起 `make dev`，确认 LangGraph Server 把 `ai_writing_probe` 列入 assistant 列表。
-3. 用 Python SDK 客户端（`langgraph_sdk.get_client()`）：
-   ```python
-   from langgraph_sdk import get_client
-   client = get_client(url="http://localhost:8001/api/langgraph")
-   thread = await client.threads.create()
-   async for chunk in client.runs.stream(
-       thread["thread_id"], "ai_writing_probe",
-       input={"user_intent": "测试", "article_type": "analysis", ...},
-       stream_mode=["values", "messages-tuple", "custom"],
-   ): print(chunk)
-   # 跑到 pause_material_confirm 应该收到 interrupt 事件
-   await client.runs.stream(thread["thread_id"], "ai_writing_probe",
-       command={"resume": {"action": "confirm", "approvedMaterialIds": [...]}})
-   ```
-4. 验证：interrupt 能正确暂停、`Command(resume=...)` 能续跑、state 能持久化到 Server checkpoint。
-5. 跑通后**回滚 langgraph.json** —— 这一步只是"摸路"。
-
-**通过条件**：4 个 pause 点全部能用 SDK 跑通 interrupt + resume。如果某个 pause 点的 payload 结构跟 SDK 协议不兼容（例如用了非 JSON 可序列化的对象），阶段 0 就要解决，否则会在阶段 2 翻车。
-
----
-
-### 阶段 1：graph 注册为 assistant（0.5 d）
-
-**改动文件**：`packages/harness/deerflow/agents/ai_writing/graph.py`、`offline-backend-20260512/backend/langgraph.json`
-
-1. `graph.py` 顶部新增：
-   ```python
-   from langchain_core.runnables import RunnableConfig
-
-   def make_ai_writing_graph(config: RunnableConfig | None = None):
-       """LangGraph Server 入口：不接收 checkpointer，由 Server 注入。"""
-       g = StateGraph(AIWritingState)
-       # ... 跟现在 build_ai_writing_graph 完全一样的节点 / 边定义 ...
-       return g.compile()   # 注意：不传 checkpointer
-   ```
-2. 旧的 `build_ai_writing_graph(checkpointer=None)`、`get_ai_writing_graph()`、`_get_async_checkpointer()`、`get_ai_writing_checkpointer()`、`shutdown_ai_writing_graph()` 全部**先标 `@deprecated` 暂留** —— 阶段 7 再删，避免阶段 2/3 出错时无法快速回退。
-3. `langgraph.json`：
-   ```json
-   {
-     "graphs": {
-       "lead_agent": "deerflow.agents:make_lead_agent",
-       "canvas_agent": "deerflow.agents.canvas_agent:make_canvas_agent",
-       "ai_writing": "deerflow.agents.ai_writing.graph:make_ai_writing_graph"
-     }
-   }
-   ```
-4. `checkpointer.path` 已经指向 `make_checkpointer`（看 `langgraph.json:15-17`），AI 写作直接共享主 checkpointer 即可，**不要**重新搞一套。
-
-**通过条件**：启动 LangGraph Server 后 `GET /api/langgraph/assistants` 能列出 `ai_writing`，state schema 字段齐全。
-
----
-
-### 阶段 2：节点改造 —— 流式输出走原生通道（1.5 d）
-
-**核心问题**：现在的 `writer_draft_node` / `writer_outline_node` / `researcher_node` 通过 `config["configurable"]["sse_queue"]` 把 LLM token chunk 推给前端。LangGraph Server 不会再注入 `sse_queue`，必须改用原生流通道。
-
-**选型**：用 `langgraph.config.get_stream_writer()` 推 `custom` 事件（保留现有"非聊天消息、自定义协议"的形态）。
-
-> 不选 `messages-tuple` 模式的原因：草稿生成不是聊天消息流，而是大段 markdown；硬塞成 `AIMessage` 会让前端渲染逻辑变得很别扭。custom 通道改动最小、契合度最高。
-
-**改造模板**（每个节点都按这个模板改）：
-```python
-# 旧：
-from .nodes._utils import push_sse_event
-async def writer_draft_node(state, config):
-    sse_queue = config["configurable"].get("sse_queue")
-    sse_queue.put_nowait({"event": "progress", "data": {...}})
-    async for chunk in llm.astream(...):
-        sse_queue.put_nowait({"event": "draft_chunk", "data": {"text": chunk}})
-
-# 新：
-from langgraph.config import get_stream_writer
-async def writer_draft_node(state, config):
-    writer = get_stream_writer()   # 注意：必须在 async 函数体内调，不能模块级缓存
-    writer({"type": "progress", "agent": "writer", "message": "开始写作"})
-    async for chunk in llm.astream(...):
-        writer({"type": "draft_chunk", "text": chunk})
-```
-
-**业务表写入改造**：现在 `writer_draft_node` 收尾时通过 `config["configurable"]["sse_session_id"]` + `_session_repos[sid]` 调 `repo.save_draft()`。新方案：
-```python
-async def writer_draft_node(state, config):
-    thread_id = config["configurable"]["thread_id"]   # LangGraph Server 注入
-    # 从 thread metadata / state 里拿到 user_id（在阶段 4 写入）
-    user_id = state.get("_user_id") or config["configurable"].get("user_id")
-    repo = get_ai_writing_session_store()  # 进程内全局，无 per-session 字典
-    try:
-        await repo.save_draft(thread_id, user_id, state["current_draft"])
-    except Exception:
-        logger.exception("save_draft failed (non-fatal)")
-```
-
-**注意事项**：
-- `get_stream_writer()` 在子图 / 工具函数里会拿到当前 graph 的 writer，**不要**在模块 import 时缓存。
-- 节点要兼容"测试场景下没有 LangGraph runtime"：包一层 `try: writer = get_stream_writer() except ...`，单测里 writer 是 no-op。
-- progress_events 字段保留写入 state（现在节点都已经 return `{"progress_events": [...]}`），这样 history / 回放仍然能在 state 里看到完整轨迹；custom stream 只是为了**实时推送**。
-
-**通过条件**：手动跑一次 `make dev`，用 SDK 客户端从前一阶段验证脚本流式拿到 `draft_chunk` 事件。
-
----
-
-### 阶段 3：前端接入 LangGraph SDK（1 d）
-
-**核心改动**：`frontend-web/src/open-canvas/api/ai-writing.ts` 整文件作废，改写 `frontend-web/src/open-canvas/hooks/useAIWritingStream.ts`。
-
-**新 hook 骨架**（参考 `frontend-web/src/core/threads/hooks.ts:207` 现有主聊天写法）：
-```ts
-import { useStream } from "@langchain/langgraph-sdk/react";
-import { Command } from "@langchain/langgraph-sdk";
-import { getAPIClient } from "@/core/api/api-client";
-
-interface AIWritingValues {
-  user_intent: string;
-  article_type: string;
-  status: string;
-  material_package?: MaterialPackage;
-  current_outline?: Outline;
-  current_draft?: DraftArticle;
-  review_result?: ReviewResult;
-  progress_events: any[];
-}
-
-export function useAIWritingStream(sessionId: string | "new") {
-  const stream = useStream<AIWritingValues, { CustomEventType: AIWritingCustomEvent }>({
-    client: getAPIClient(),
-    assistantId: "ai_writing",
-    threadId: sessionId === "new" ? undefined : sessionId,
-    reconnectOnMount: true,
-    onCreated(meta) {
-      // 后端会用同一个 thread_id 做 ai_writing_sessions.id；通知 UI 写入 URL
-      navigateTo(`/workspace/ai-writing/${meta.thread_id}`);
-    },
-    onCustomEvent(event) {
-      // 节点 push 来的 draft_chunk / progress / notice
-      pushUIEvent(event);
-    },
-  });
-  return stream;
-}
-```
-
-**4 个干预卡的提交逻辑**（旧 → 新）：
-```ts
-// 旧（自写 fetch）：
-await fetch(`/api/ai-writing/${sessionId}/resume`, {
-  method: "POST",
-  body: JSON.stringify({ action: "confirm", approvedMaterialIds: [...] }),
-});
-
-// 新（SDK 原生 Command）：
-stream.submit(undefined, {
-  command: { resume: { action: "confirm", approvedMaterialIds: [...] } },
-});
-```
-
-**启动写作**：
-```ts
-// 旧：POST /start → 返回 session_id → 建 EventSource
-// 新：
-stream.submit({
-  user_intent, article_type, target_audience, word_count_target, keyword_count, writing_mode,
-}, {
-  config: { configurable: { model_name } },
-  metadata: { feature: "ai_writing", article_type },   // 走业务表筛选
-});
-```
-
-**列表页 / 历史回显**：仍然走 `GET /api/ai-writing/sessions` 业务 API，**无改动**。点进某条历史记录时：
-- 拿到 `sessionId` (== LangGraph `thread_id`)
-- `useAIWritingStream(sessionId)` 自动调 `client.threads.getState()` 拉最新 state，渲染最后一次草稿 / 干预点 / interrupt 等待
-- 已结束的会话 (`status == "done"`) 直接读业务表的 `draft_markdown` 字段，**不挂 SDK stream**（省 Server 资源）
-
-**通过条件**：手动跑完一个完整流程（启动 → 4 次干预 → 拿到草稿），过程中刷新页面 / 切 worker，进度都不丢。
-
----
-
-### 阶段 4：业务表写入解耦（0.5 d）
-
-**问题**：现在 `/start` 路由先 INSERT 一行 `ai_writing_sessions(id=session_id, ...)`，再启动 graph。迁移后前端用 `stream.submit(...)` 直接触发 LangGraph 建 thread + 跑 graph，业务表行没人建 → 列表页查不到。
-
-**两个方案二选一**：
-
-**方案 4A（推荐）**：节点里建业务表行
-- `intent_parser_node` 开头：`await repo.upsert_session(thread_id, user_id, user_intent, article_type, status="researching")`
-- 优点：单一数据源（节点），不依赖前端做"双写"。
-- 缺点：用户从前端点"启动" → 看到列表里出现这条 → 之间有 200~500ms 延迟（intent_parser 跑完才入库），需要前端 onCreated 后乐观插入一条临时行。
-
-**方案 4B**：前端 onCreated 时调一个轻量 upsert API
-- 新增 `POST /api/ai-writing/sessions/{thread_id}/init`：只插业务表行，不碰 graph。
-- 前端 `onCreated(meta)` 回调里立刻 fire-and-forget 调它。
-- 优点：列表瞬间出现新行。
-- 缺点：前端要多调一次 API，且失败要兜底；多了一条"双方都能建行"的路径。
-
-**推荐 4A** —— 单一数据源比 UI 响应更重要，200ms 延迟用 loading skeleton 即可。
-
-**用户身份传递**：节点要拿到 `user_id` 写入业务表。两条路：
-- LangGraph Server 已有 `langgraph_auth.py` 注入 auth context，在节点里 `config["configurable"].get("langgraph_auth_user")` 取（具体字段名以现有实现为准）。
-- 或者前端 `submit()` 时 metadata 里带上 `user_id`，节点从 `config["configurable"]["metadata"]` 拿。
-
-**通过条件**：从启动到列表显示新行，延迟 < 1s；多用户场景下不会出现"A 用户的 thread 落到 B 的业务表行"。
-
----
-
-### 阶段 5：transcript 持久化（0.2 d）
-
-**当前**：前端 `PUT /api/ai-writing/sessions/{id}/transcript` 全量覆盖 `ai_writing_sessions.transcript` 列。
-
-**改造选择**：
-- **维持现状**（推荐）：transcript 是前端组装的时间线 blob，让前端继续 fire-and-forget PUT 即可，跟迁移正交。
-- 或者完全弃用 transcript 列，直接从 `client.threads.getHistory()` + `getState()` 还原 —— 工作量大且需要重写回显逻辑，**不推荐第一版做**。
-
-**通过条件**：原 PUT 接口照常工作；新建会话也能落库。
-
----
-
-### 阶段 6：admin 清理改造（0.3 d）
-
-**改动文件**：`app/gateway/ai_writing_cleanup.py`
-
-```python
-# 旧：
-saver = get_ai_writing_checkpointer()
-await saver.adelete_thread(sid)   # 自管 sqlite
-
-# 新：
-from langgraph_sdk import get_client
-lg_client = get_client(url=internal_langgraph_url())
-await lg_client.threads.delete(sid)
-```
-
-**活跃保护**：旧逻辑是看 `sid in _event_queues`。新逻辑：
-```python
-state = await lg_client.threads.get_state(sid)
-is_active = (
-    state.get("next")                   # graph 还有未执行的节点
-    or state.get("tasks")               # 当前有 pending task
-    or state.get("metadata", {}).get("interrupted")  # 卡在 interrupt 上
-)
-if is_active:
-    skipped_active += 1
-    continue
-```
-
-**通过条件**：admin cleanup 接口照常返回 `deleted_db / deleted_checkpoints / skipped_active`，且能正确跳过仍在 interrupt 等待用户的会话。
-
----
-
-### 阶段 7：删冗余代码（0.3 d）
-
-按 §2.1 列表逐项删除。建议**单独开一个 PR**，跟阶段 1~6 解耦：
-- 前 6 个 PR 全部上线、灰度验证至少 1 周
-- 确认旧代码路径再无流量后，再走清理 PR
-- 这样万一灰度阶段需要回滚，旧路径还在
-
-**通过条件**：`make test` 全绿，`grep -r "_event_queues\|_session_pending_pause\|_recover_session" app/ packages/` 零命中。
-
----
-
-### 阶段 8：测试 + 灰度（1 d）
-
-**新增测试**：
-- `tests/test_ai_writing_assistant.py` —— 用 `langgraph_sdk` 客户端打 LangGraph Server，覆盖：
-  - 完整流程：start → 4 个 interrupt → resume → done
-  - state 持久化：跑到 pause_outline 后重建客户端，能 `getState` 看到 outline
-  - custom stream：能收到 `draft_chunk` 等事件
-  - 错误兜底：节点抛错时 status 落 error、业务表 status 同步
-- 保留 `tests/test_portable_long_text.py` / `tests/test_ai_writing_transcript_endpoint.py` / `tests/test_ai_writing_session_repo.py` —— 这几个跟业务表强相关，不受迁移影响。
-
-**删除测试**：
-- `tests/test_ai_writing_session_recovery.py` —— 跨 worker 恢复改由 LangGraph Server 提供，不再是 AI 写作自己的能力。
-- `tests/test_ai_writing_cleanup.py` 里关于"drain + checkpointer 降级 + SSE 序列化"的几个用例 —— 这些机制已删，对应用例失效。
-
-**灰度策略**：
-- **前端开关**：`VITE_AI_WRITING_BACKEND` = `legacy | langgraph`，默认 `legacy`
-  - `legacy` → 走老的 `fetch + EventSource + /resume`
-  - `langgraph` → 走新 `useAIWritingStream`
-- **后端**：旧路由（`/start /stream /resume /state`）保留两个发版周期，逐步下线
-- **数据兼容**：业务表 schema 完全不变，两条路径都用同一张表
-- **回滚成本**：改回 `VITE_AI_WRITING_BACKEND=legacy` 重新部署即可，无 DB migration
-
-**通过条件**：
-- 灰度环境跑 100+ 写作流程，对比新旧两条路径的成功率、SSE 中断率、resume 成功率
-- 新路径在 worker=4 部署下 SSE 中断率 = 0（旧路径基线约 5~15%）
-
----
-
-## 四、关键设计决策与权衡
-
-### 4.1 为什么不让 LangGraph checkpoint 替代业务表？
-
-LangGraph checkpoint 存的是"图执行状态"，业务表存的是"产品形态"。两者职责不同：
-- **会话列表筛选/排序**：业务表 `WHERE user_id = ? AND status = ? ORDER BY updated_at` —— LangGraph checkpoint 没法这样查（它是 `(thread_id, checkpoint_ns)` 主键）
-- **全文搜索 draft**：业务表 `LIKE '%关键词%'` —— checkpoint 是序列化 blob
-- **transcript 自定义 UI 协议**：前端组装的时间线 JSON，跟 graph state 不一一对应
-
-**结论**：两者**并存**，`thread_id` 作为外键。这是主聊天的做法（`threads_meta` + LangGraph checkpoint），AI 写作迁完后也是同样的形态。
-
-### 4.2 为什么 graph 节点里直接调 repo，不发到外面消费？
-
-考虑过"节点只 emit custom event，路由层订阅事件后写业务表" —— 但这又把状态分散回路由层了。
-
-直接在节点里调 `await repo.save_draft(...)`：
-- 节点拿得到 `thread_id`（== session_id == business id），主键一致
-- `repo` 是单例（DB 连接池），不依赖 per-session 字典
-- 写入失败包 try/except 即可（草稿落 state 比落 DB 更关键，DB 失败不阻断流程）
-
-### 4.3 为什么用 custom stream 而不是 messages-tuple？
-
-writer_draft 输出是大段 markdown，强行包成 `AIMessage` 后：
-- 前端要把它从消息列表里拎出来当草稿渲染（混杂）
-- 大纲 / 审核结果是结构化 JSON，更不像聊天消息
-- progress_events / notice / draft_chunk / outline_chunk 几种事件类型，全塞 message 通道得发明 metadata convention
-
-custom stream 是为这种"非聊天但需要流式 push"场景设计的，匹配度更高。
-
-### 4.4 在 Server 进程里跑 graph，资源够用吗？
-
-LangGraph Server 是独立 Python 进程，跟 Gateway 共享同一台机器但不共享内存。新增一个 assistant 的常驻开销 ~10 MB（graph 编译后的 schema 缓存），每个并发会话峰值 ~50 MB（LLM client + state）。
-
-实测建议：在阶段 0 之后跑一次 10 个并发的压测，观察 Server RSS 增量。若一台机器 4 GB 内存，理论支撑 60~80 并发 AI 写作，足够 50 人规模团队使用。
-
----
-
-## 五、风险清单
-
-| # | 风险 | 缓解 |
-|---|---|---|
-| R1 | LangGraph Server 升级版本时 `interrupt()` / `Command(resume=...)` 协议有 breaking change | 在 `pyproject.toml` 里 pin `langgraph` minor 版本；升级前先在阶段 0 那个 probe 跑一遍冒烟 |
-| R2 | 前端 `useStream` 的 `reconnectOnMount` 行为跟自写 EventSource 不完全一致，刷新页面后某些情况下不会自动续接 SSE | 阶段 3 手动测刷新场景；如不达预期，配合 `client.threads.getState()` 拉一次 state 兜底 |
-| R3 | 节点里 `get_stream_writer()` 在单测里没有 LangGraph runtime → 抛错 | 节点 wrap `try: writer = get_stream_writer() except: writer = lambda x: None` |
-| R4 | 多用户场景下 `langgraph_auth.py` 没对 ai_writing assistant 做隔离，可能跨用户拿到别人的 thread state | 阶段 4 一并配置 auth；新增专项测试 |
-| R5 | `client.threads.delete()` 是异步删，admin 清理脚本调完后立即查 state 还能短暂查到 → `skipped_active` 误判 | 删之前先 lock thread 或调用 `client.runs.cancel()` 强制收敛 |
-| R6 | LangGraph Server 自带 checkpoint 仍然是 sqlite（`langgraph.json` 里配的），在容器重启时跟 AI 写作原有的 `.deer-flow/data/checkpoints.db` 是同一个文件 → schema 共用 | 阶段 1 之前先确认主 checkpointer 配置路径，避免双开 sqlite 文件锁竞争 |
-| R7 | 现有用户在迁移窗口期发起的会话，灰度切到新路径后无法续跑（state 在旧 sqlite，新路径查不到） | 迁移前 1 小时禁止新会话；或写一个一次性脚本把旧 checkpointer 的 thread 复制到主 checkpointer |
-
----
-
-## 六、工时与里程碑
-
-| 阶段 | 工时 | 可独立交付 |
-|---|---|---|
-| 阶段 0：可行性预演 | 0.5 d | ✅ |
-| 阶段 1：graph 注册 | 0.5 d | ❌（后端只生效，前端没接） |
-| 阶段 2：节点改造 | 1.5 d | ❌ |
-| 阶段 3：前端接入 | 1 d | ✅（带开关上灰度） |
-| 阶段 4：业务表写入解耦 | 0.5 d | ❌（跟阶段 3 合并发） |
-| 阶段 5：transcript | 0.2 d | ✅ |
-| 阶段 6：admin 清理改造 | 0.3 d | ✅ |
-| 阶段 7：删冗余 | 0.3 d | ✅（独立 PR，灰度后再发） |
-| 阶段 8：测试 + 灰度 | 1 d | ✅ |
-| **核心工时** | **5.8 d** | |
-| **+ 50% buffer** | **8.7 d ≈ 9 d** | |
-
-**建议排期**：
-- 第 1 周：阶段 0 + 1 + 2（后端完整、本地能跑通）
-- 第 2 周：阶段 3 + 4 + 5 + 6（前端 + 业务集成）
-- 第 3 周：阶段 8（测试 + 灰度）
-- 灰度 1~2 周后：阶段 7（删冗余）
-
----
-
-## 七、回滚预案
-
-每个阶段都设计为可独立回滚：
-
-| 场景 | 回滚动作 |
-|---|---|
-| 阶段 3 上线后发现 SSE 不稳 | 前端开关 `VITE_AI_WRITING_BACKEND=legacy`，重新部署，0 dataloss |
-| 阶段 7 删冗余代码后发现新路径有问题 | 从 git revert 删除 commit，恢复旧路由代码；业务表/checkpoint 不受影响 |
-| 阶段 1 注册 assistant 后 LangGraph Server 起不来 | 从 `langgraph.json` 移除 `ai_writing` 那一行，重启 Server，回到迁移前状态 |
-
-**数据兼容承诺**：
-- 业务表 schema 完全不变
-- `thread_id` (== `ai_writing_sessions.id`) 含义保持一致
-- transcript 列含义不变
-
-**最坏回滚**：把 `VITE_AI_WRITING_BACKEND` 改回 `legacy`、`langgraph.json` 删 `ai_writing` 那行，回到迁移前的"方案 C/F/B 路径"。已经走完的会话留在新 checkpoint 里成"孤儿"，但业务表里的草稿和审核结果**完整无损**。
-
----
-
-## 八、迁移成功后能享受的"免费红利"
-
-1. **完整 history API**：`client.threads.getHistory(thread_id)` 拿到每一步 checkpoint，做"回到某一步重试"非常便宜
-2. **time travel**：用户能从任意 checkpoint 分叉重写
-3. **跟主聊天共享基础设施**：升级 LangGraph 版本时一并升级，不用维护两套 SSE / checkpoint 协议
-4. **天然支持水平扩容**：哪天上 K8s 多副本部署，AI 写作跟主聊天一样开箱即用
-5. **天然支持 IM 渠道接入**：`app/channels/` 那套 Feishu / Slack 实现是 `langgraph-sdk` 的，迁完后 AI 写作也能在 IM 里用，零额外代码
-
----
-
-## 九、相关文件索引（迁移前后参照）
-
-### 现状（迁前）
-- `app/gateway/routers/ai_writing.py:148-176` —— 8 个模块级 dict + drain task
-- `packages/harness/deerflow/agents/ai_writing/graph.py:370-538` —— 自管 checkpointer
-- `frontend-web/src/open-canvas/api/ai-writing.ts` —— 自写 fetch + EventSource
-
-### 参照（主聊天迁后形态）
-- `frontend-web/src/core/threads/hooks.ts:207` —— `useStream` 用法
-- `frontend-web/src/core/api/api-client.ts` —— LangGraph SDK Client 初始化
-- `offline-backend-20260512/backend/langgraph.json` —— assistant 注册位置
-- `offline-backend-20260512/backend/packages/harness/deerflow/agents/lead_agent/` —— graph 工厂参考写法
-- `offline-backend-20260512/backend/packages/harness/deerflow/runtime/checkpointer/async_provider.py` —— 共享 checkpointer 入口
-
-### 目标（迁后）
-- 新增：`packages/harness/deerflow/agents/ai_writing/graph.py:make_ai_writing_graph`
-- 新增：`frontend-web/src/open-canvas/hooks/useAIWritingStream.ts`
-- 删除：`app/gateway/routers/ai_writing.py` 中的 `/start /stream /resume /state` 路由 + 8 个 dict
-- 删除：`frontend-web/src/open-canvas/api/ai-writing.ts` 中的 `startWriting / streamSession / resume` 全部 fetch 调用
-- 简化：`app/gateway/ai_writing_cleanup.py`（改用 SDK client 删 thread）
-
----
-
-## 十、决策摘要（给 PM / 维护者）
-
-> **TL;DR**
-> 1. 主聊天不受多 worker 影响，是因为它把状态托管给了独立的 LangGraph Server 进程，前端直接通过 SDK 跟 Server 通信。AI 写作要做同样的事。
-> 2. 改造范围：后端 graph 注册 + 节点流通道改造 + 前端 hook 换 SDK + 业务表写入解耦。**核心约 6 人日，含 buffer 9 人日**。
-> 3. 业务表、节点逻辑、4 个干预点、UI 形态全部保留，**用户感知层面零变化**。
-> 4. 改造完一次性获得"刷新不丢进度、多 worker 不裂、跟主聊天共享基础设施、IM 渠道免费支持"等长期红利。
-> 5. 建议跟"方案 C"并行：先按 [ai-writing-说明.md](./ai-writing-说明.md) 上方案 C 应急止血，本方案作为长期改造按周排期。两者不冲突，方案 C 上线即受益，本方案完工后可下线方案 C 的双进程配置。

frontend-web/docs/ai-writing-内置智能体改造.md

@@ -0,0 +1,253 @@
+# AI 写作「四阶段内置智能体化」改造方案
+
+> 目标：把 AI 写作现有的 **素材收集专家 / 写作大纲 / 作家写作 / 编辑审核** 四个功能，
+> 从「硬编码的 LangGraph 节点 + 硬编码提示词」改造为由**内置功能型智能体**驱动——
+> 每个阶段对应一个可配置的内置 agent（独立人设 SOUL、可配模型、可挂技能/工具）。
+
+本文给出现状梳理、目标设计、以及**分步可独立交付的实现计划**。
+
+---
+
+## 0. 一句话结论
+
+不推倒重来。**保留现有图的编排骨架、4 个用户干预点、流式与状态机，只把每个阶段节点的「大脑」从「硬编码 prompt 直调 LLM」替换为「加载对应内置 agent 的 SOUL+配置、在子线程上跑该 agent、按结构化契约解析其输出」。** 这样前端几乎不动，复杂逻辑（严格模式、素材不足求助、逐章流式、技能检索步骤）全部保留。
+
+---
+
+## 1. 现状梳理（精确到文件）
+
+AI 写作是一条 LangGraph 图：`packages/harness/deerflow/agents/ai_writing/graph.py`
+
+```
+intent_parser → researcher → (pause 素材确认) → writer_outline → (pause 大纲确认)
+   → writer_draft → (pause 草稿确认 / 素材不足求助) → editor → (pause 编辑打回) → done
+```
+
+四个待改造阶段（均为**硬编码节点**，直接调 LLM、不走 agent 运行时）：
+
+| 阶段（用户语言） | 节点文件 | 提示词 | 产出（`state.py`） |
+|---|---|---|---|
+| 素材收集专家 | `nodes/researcher.py` | `prompts/researcher_prompts.py` | `material_package`（keywords + materials） |
+| 写作大纲 | `nodes/writer_outline.py` | `prompts/writer_prompts.py` | `current_outline`（Outline JSON） |
+| 作家写作 | `nodes/writer_draft.py` | `prompts/writer_prompts.py` | `current_draft`（Markdown，逐章流式） |
+| 编辑审核 | `nodes/editor.py` | `prompts/editor_prompts.py` | `review_result`（评分 + 问题列表 JSON） |
+
+关键事实：
+- **LLM 调用方式**：节点通过 `nodes/_utils.py` 的 `get_model()` + `llm_json()` **直接调 LLM**，提示词写死在 `prompts/*.py`。**没有**走 agent 人设 / 技能 / 工具体系。
+- **模型**：全程单一 `state.model_name`（用户在写作表单里选的主模型），各阶段无法分别配。
+- **干预点 / 流式 / 严格模式 / 素材不足求助**：都在 `graph.py` 的 pause 节点和 `writer_draft` 里，逻辑较重，需原样保留。
+- **前端**：`frontend-web/src/open-canvas/contexts/AIWritingContext.tsx` 是状态机（`researching/writing_outline/writing_draft/reviewing/...`），时间线 `AIWritingTimeline.tsx` 按 `progress_events`（已带 `agent_name` 字段）渲染。
+
+---
+
+## 2. 可复用的现成机制（不用造轮子）
+
+代码库里**已经有**一套成熟的「内置功能型智能体」范式——圆桌的 `roundtable-intent / roundtable-recommender / roundtable-coordinator`：
+
+1. **资源即代码**：`app/gateway/routers/_roundtable_seed_assets/<agent-id>/`
+   - `config.yaml`（`id` / `name` / `description`，可扩展 `model` / `skills` / `tool_groups`）
+   - `SOUL.md`（人设 + 职责 + 工作流 + **结构化输出契约**）
+2. **种子器**：`app/gateway/routers/_roundtable_seed.py::ensure_roundtable_functional_agents`
+   - 启动时 + 相关路由入口自愈：目录不存在才从资源字节级落盘到 `.deer-flow/agents/<id>/` + DB（**已存在则永不覆盖**，尊重本地编辑）。
+3. **运行**：在**独立 thread** 上跑该内置 agent（见 `app/gateway/routers/intent.py`，`INTENT_AGENT_ID = "roundtable-intent"`），通过 lead agent 运行时把 SOUL.md 作系统提示，流式经 LangGraph `custom`/`messages` 通道透传。
+4. **结构化输出约定**：SOUL 规定模型末尾输出固定 **marker + ```json```**（如 `[INTENT_READY]\n```json{...}```），后端用正则解析（`intent.py::_INTENT_READY_PATTERN`）。
+
+> 我们要做的，本质就是**照搬这套范式，给 AI 写作做 4 个功能型 agent**，并让对应的图节点改成「跑这个 agent + 解析其结构化输出」。
+
+另有 agents 通用体系可复用：`agents` 表、`/api/agents` CRUD、智能体管理页（配模型/技能/工具）——4 个写作 agent 落盘后天然出现在这里，可被 admin 编辑。
+
+---
+
+## 3. 目标设计
+
+### 3.1 四个内置写作智能体（建议 id / 职责）
+
+| Agent id | 名称 | 取代节点 | 结构化输出 marker | 产出 schema |
+|---|---|---|---|---|
+| `ai-writing-researcher` | 素材收集专家 | `researcher` | `[MATERIALS_READY]` | `MaterialPackage` |
+| `ai-writing-outliner` | 大纲规划师 | `writer_outline` | `[OUTLINE_READY]` | `Outline` |
+| `ai-writing-writer` | 作家 | `writer_draft` | `[SECTION_READY]`（逐章） | 章节 Markdown |
+| `ai-writing-editor` | 编辑 | `editor` | `[REVIEW_READY]` | `ReviewResult` |
+
+每个 agent 自带：
+- `config.yaml`：`id / name / description` +（扩展）`model`（该阶段专用模型，可空=回退用户主模型）、`skills`（如 researcher 挂检索技能）、`tool_groups`。
+- `SOUL.md`：由现有 `prompts/*.py` 内容迁移改写，**追加结构化输出契约**（严格 marker + JSON 格式 + 反例，仿 `roundtable-intent` SOUL 的「硬规则」写法，压制弱模型乱输出）。
+
+### 3.2 节点改造方式（核心）
+
+每个阶段节点保留**输入/输出契约不变**（仍读写 `state` 的同一批字段），内部从：
+
+```
+# 旧：硬编码 prompt 直调
+model = get_model(config, state["model_name"])
+result = llm_json(model, SYSTEM_PROMPT, USER_PROMPT.format(...))
+```
+
+改为：
+
+```
+# 新：跑对应内置 agent，按 marker 解析
+result = await run_writing_agent(
+    agent_id="ai-writing-outliner",
+    state=state, config=config,
+    user_payload=<本阶段输入>,        # 意图/素材/大纲/草稿等拼成的一段输入
+    marker="[OUTLINE_READY]",         # 结构化输出契约
+)
+```
+
+新增统一助手 `nodes/_agent_runner.py::run_writing_agent(...)`：在子 thread 上跑指定内置 agent（复用 `intent.py` 的 run/stream 机制）、把流式 chunk 透传到 `custom` 通道（前端时间线不回归）、用复用的 `_utils.parse_json` 多级容错解析 marker 后的 JSON。
+
+### 3.3 为什么选这个方案（A）而非全多智能体重写（B）
+
+- **方案 A（推荐）**：保留图骨架，逐节点替换大脑。前端基本不动；干预点/流式/严格模式/素材求助原样保留；可**按阶段灰度 + feature flag 回退**，风险可控。
+- **方案 B（不推荐）**：仿圆桌重做成多 agent 编排，需重写编排、状态、流式、4 个干预点对接，工作量数倍、回归面巨大，收益（更"纯"的多 agent）对本场景并不必要。
+
+---
+
+## 4. 配置与可管理性
+
+- **落盘**：仿 roundtable 新增 `_ai_writing_seed_assets/` + 一个 `ensure_ai_writing_functional_agents()` 种子器，在 Gateway 启动与 ai_writing 会话入口自愈。
+- **管理界面**：4 个 agent 落盘后即出现在智能体管理页，admin 可编辑 **SOUL（人设）/ 模型 / 挂载技能**。可选：在「文章类型配置页」旁加一个「写作智能体配置」入口，或给这 4 个打一个 `tag` 便于筛选。
+- **模型优先级**：节点跑 agent 时 `该 agent config.model > 用户写作表单选的主模型 model_name`（保留现有"用户选模型"语义，新增 per-阶段覆盖能力）。
+- **技能**：researcher 现有的技能检索能力（`search/skill_search.py`）改为 `ai-writing-researcher` 的**挂载技能**，admin 可增减；检索步骤事件（`SkillStep`）形态保留给前端展示。
+
+---
+
+## 5. 分步实现计划（每步可独立交付 / 验收）
+
+### Phase 0 · 契约冻结
+- 定 4 个 agent 的 `id / name`、每个的 **marker + JSON schema**（与 `state.py` 的 `MaterialPackage/Outline/DraftArticle/ReviewResult` 严格对齐）。
+- **验收**：本文 §3.1 / §6 的契约评审通过、字段与现有 TypedDict 一一对应。
+
+### Phase 1 · 内置 agent 种子化（后端，纯新增，不接管流程）
+- 新建 `app/gateway/routers/_ai_writing_seed_assets/<4 个 agent>/{config.yaml, SOUL.md}`；SOUL 由现有 `prompts/*.py` 迁移改写 + 追加结构化输出契约。
+- 仿 `_roundtable_seed.py` 写 `ensure_ai_writing_functional_agents()`，挂到启动 lifespan + ai_writing 入口。
+- **验收**：启动后 4 个 agent 出现在 `.deer-flow/agents/`、DB、`/api/agents`，能在智能体管理页查看/编辑；**此阶段不改图，写作流程行为不变**。
+
+### Phase 2 · 节点接入「跑内置 agent」（后端，逐阶段灰度）
+- 新增 `nodes/_agent_runner.py::run_writing_agent(...)`（子线程跑 agent + 流式透传 + marker 解析）。
+- 加 feature flag：`config.yaml → ai_writing.use_builtin_agents.{editor,outliner,researcher,writer}`（默认 false=走旧节点）。
+- **接入顺序（由易到难）**：
+  1. **editor**（最简单：小 JSON、无检索、无逐章流式）→ flag 打开端到端验证。
+  2. **outliner**（输出 Outline JSON）。
+  3. **researcher**（保留技能检索步骤事件、素材确认暂停）。
+  4. **writer**（最难：保留**逐章流式** + **严格模式素材不足求助** `blocked_sections`；建议**仍由节点控制"逐章循环"**，每章调一次 `ai-writing-writer`，`section_help` 暂停逻辑不动）。
+- 每接一个，旧 prompt 与旧逻辑**保留**，节点按 flag 二选一。
+- **验收**：每个阶段 flag 打开后端到端走通，产出结构与旧版一致，干预点 / 流式 / 严格模式 / 求助暂停均不回归。
+
+### Phase 3 · 每阶段 agent 配置化
+- per-agent 模型覆盖生效（`agent.config.model > model_name`）。
+- researcher 的检索能力改为挂载技能，admin 可增减。
+- 智能体管理页可编辑这 4 个的 SOUL / 模型 / 技能；config 热加载，新会话即生效、不重启前端。
+- **验收**：admin 改某阶段 agent 的模型 / SOUL / 技能后，新会话立即按新配置运行。
+
+### Phase 4 · 前端适配（小改）
+- 时间线 / 状态文案：阶段名读对应 agent 的 `name`（`progress_events.agent_name` 已存在，基本沿用，去掉写死文案）。
+- 可选：写作表单 / 设置加「查看·配置写作智能体」入口，跳智能体管理页。
+- **验收**：前端展示各阶段对应的智能体名；配置入口可达。
+
+### Phase 5 · 清理收口
+- 四阶段稳定后，默认打开全部 flag、移除旧 prompt 直调路径与 flag（prompts 历史留在 git）。
+- 更新 `offline-backend-20260512/backend/CLAUDE.md` 架构描述。
+- **验收**：回归测试通过、冗余删除、文档同步。
+
+---
+
+## 6. 结构化输出契约（与现有 state 对齐）
+
+各 agent SOUL 末尾必须输出 `marker + ```json``` 块，schema 直接对齐 `state.py`：
+
+- `ai-writing-researcher` → `[MATERIALS_READY]`：`{ "keywords": string[], "materials": Material[] }`（`Material` 见 `state.py`，含 `id/title/content/source/relevance_score/source_type/...`）。
+- `ai-writing-outliner` → `[OUTLINE_READY]`：`Outline = { "title": string, "sections": OutlineSection[] }`（`OutlineSection = { section_title, key_points: KeyPoint[], material_ids }`）。
+- `ai-writing-writer` → 逐章 `[SECTION_READY]`：`{ "section_title": string, "markdown": string, "needs_more_material"?: { "reason": string } }`（`needs_more_material` 触发严格模式求助 `blocked_sections`）。
+- `ai-writing-editor` → `[REVIEW_READY]`：`ReviewResult = { "verdict": "pass"|"reject", "fact_score", "logic_score", "language_score", "overall_score", "pass_threshold", "revision_notes": ReviewIssue[] }`。
+
+解析复用 `nodes/_utils.py::parse_json`（多级容错），marker 正则仿 `intent.py::_INTENT_READY_PATTERN`。
+
+---
+
+## 7. 风险与注意
+
+1. **弱模型结构化输出不稳**：SOUL 写严格格式 + 反例 + 「输出 marker 后立刻闭嘴」硬规则（仿 `roundtable-intent` SOUL §0）；解析层复用 `parse_json` 多级降级。
+2. **writer 的逐章流式 + 严格模式求助最复杂**：建议**循环控制权留在节点**（每章调一次 agent），不要让 agent 一次吐全文，否则 `blocked_sections` / `section_help` / 逐章流式都要重做。
+3. **researcher 技能检索步骤事件**（`SkillStep`）前端有专门卡片：迁移时保留这些 `progress_events` 形态。
+4. **种子器 never-overwrite**：迭代 SOUL 后**老部署不会自动更新**（与圆桌同一问题）。运维更新办法：删 `.deer-flow/agents/<id>/` 重新种子，或后续给种子器加「内置功能 agent 按版本/hash 覆盖」开关。
+5. **子线程隔离**：跑写作 agent 的子 thread 与主 ai_writing thread 状态隔离，注意 checkpointer 与清理（沿用 ai_writing 既有的会话清理）。
+6. **离线内网**：researcher 的检索一律走技能（不联网），与现有「离线部署禁 web_search、走 skill」策略一致。
+
+---
+
+## 8. 涉及文件清单（落地时对照）
+
+**后端（主要改动）**
+- 新增 `app/gateway/routers/_ai_writing_seed_assets/{ai-writing-researcher,ai-writing-outliner,ai-writing-writer,ai-writing-editor}/{config.yaml,SOUL.md}`
+- 新增 `app/gateway/routers/_ai_writing_seed.py`（种子器，仿 `_roundtable_seed.py`）
+- 新增 `packages/harness/deerflow/agents/ai_writing/nodes/_agent_runner.py`（`run_writing_agent`）
+- 改 `nodes/{researcher,writer_outline,writer_draft,editor}.py`（按 flag 二选一）
+- 改 `config.yaml`（新增 `ai_writing.use_builtin_agents.*` 开关；可选 per-agent 默认模型）
+- 保留 `prompts/*.py`（回退用，Phase 5 删）
+
+**前端（小改）**
+- 改 `src/open-canvas/components/ai-writing/AIWritingTimeline.tsx`（阶段名读 agent name）
+- 可选：写作表单/设置加「配置写作智能体」入口（跳 `/page/...` 智能体管理页）
+
+**文档**
+- 本文件
+- Phase 5 收口时更新 `offline-backend-20260512/backend/CLAUDE.md`
+
+---
+
+## 9. 实施记录（2026-06-11，Phase 1-4 已落地）
+
+### 已交付
+
+- **Phase 1**：`_ai_writing_seed_assets/{ai-writing-researcher,ai-writing-outliner,ai-writing-writer,ai-writing-editor}/{config.yaml,SOUL.md}` + `_ai_writing_seed.py::ensure_ai_writing_functional_agents()`，挂启动 lifespan（`_sync_legacy_agents` 之前）+ `ai_writing.list_sessions / list_article_types` 入口自愈。
+- **Phase 2**：`nodes/_agent_runner.py`（`stream_writing_agent` / `run_writing_agent` / `parse_marker_json` / `resolve_agent_model_name` / `use_builtin_agent`）；四节点按 `config.yaml → ai_writing.use_builtin_agents.{researcher,outliner,writer,editor}` 二选一（默认全 false，config 按 mtime 热加载，改完即对新会话生效）。agent 目录缺失时节点**静默回退旧 prompt 路径**，写作流程永不因 agent 被删而中断。
+- **Phase 3（部分）**：per-agent 模型覆盖已生效（优先级 `agent config.model > 节点显式回退模型（keyword_model/rank_model）> 表单主模型 model_name`）；SOUL/模型在智能体管理页可编辑、按 mtime 热加载。researcher「检索能力改挂载技能」未做（仍走节点内 SkillPicker 编排）。
+- **Phase 4**：时间线 agent 名由后端 `progress_events.agent_name` 动态下发（flag 开启时读 agent config 的 `name`）；`TimelineStep.tsx` 补「大纲规划师」配色（未命中名字回退灰色，admin 改名不报错）。
+- **测试**：`tests/test_ai_writing_seed.py`（资源完整性 / 契约 marker / never-overwrite）+ `tests/test_ai_writing_agent_runner.py`（marker 多级解析 / 模型优先级 / flag / 流式端到端 / SOUL 缺失降级），共 31 例。
+
+### 与 §6 契约的修订（以实现为准）
+
+为保住「逐章流式打字机」「review_chunk/review_item_done 分维度卡片」「素材确认/求助暂停」等前端形态，编排控制权全部留在节点，agent 只承担**单次结构化产出**：
+
+| Agent | 实际契约 |
+|---|---|
+| `ai-writing-researcher` | 两个子任务：`[KEYWORDS_READY]` + `{"keywords": []}`；`[MATERIALS_RANKED]` + `{"ranked_ids": [], "summary": ""}`。素材本体来自节点的检索编排（agent 不联网），`MaterialPackage` 仍由节点组装 |
+| `ai-writing-outliner` | `[OUTLINE_READY]` + 完整 `Outline` JSON（新规划 / 修改模式共用，payload 开头标明任务模式） |
+| `ai-writing-writer` | **无 JSON marker**：每章直接输出 Markdown 正文（保流式）；严格模式素材不足只输出一行 `[[SECTION_BLOCKED]] 原因`（沿用原哨兵） |
+| `ai-writing-editor` | 每个维度一次调用：`[REVIEW_READY]` + `{"score": int, "issues": []}`；综合分/verdict/pass_threshold 仍由节点按 config 计算（不信任 LLM 自判通过） |
+
+另一处架构修订：**不在子 thread 上经 lead agent 运行时跑**（§3.2 原设想复用 `intent.py` 机制，但其 loopback 在 app 层，harness 图节点不可 import；且单轮结构化调用无需 thread/checkpointer/中间件成本）。`run_writing_agent` 直接「SOUL 作 system prompt + 单条输入」调模型，规避了 §7.5 的子线程隔离/清理风险。researcher 挂技能（Phase 3 剩余项）如需完整工具体系再评估接入运行时。
+
+### 已知存量测试失败（与本次无关）
+
+`test_ai_writing_graph.py`（mock 已删除的 `intent_parser.llm_json`）、`test_ai_writing_word_count.py`（mock 已删除的 `writer_draft.get_model`）、`test_ai_writing_draft_headings.py`（断言三级结构升级前的 `####→###` 行为）、`test_ai_writing_outline_revise.py`（断言旧 prompt 文案），改造前即失败，待另行清理。
+
+## 10. Phase 3 收尾：检索类型两项化 + 配置技能驱动检索（2026-06-13 已实施）
+
+本节落地了 §9 遗留的「researcher 检索改挂载技能」，并按新需求重新设计了检索类型与 PAUSE-1 交互。
+
+### 10.1 检索类型（material_source）收敛为两项
+
+- 写作表单「素材来源」改名「检索类型」，只剩 `general`（通用检索，默认）/ `notebook`（我的空间）；旧值 `knowledge_base` / `skill` 由 researcher 节点按 `general` 兼容（老会话 resume 不受影响）。
+- 前端：`AIWritingForm.tsx`（选项/标签）、`WritingFormContext.tsx`（默认值/类型/applyProposal 旧值映射）、`types/ai-writing.ts`、`message-list.tsx`（审批卡标签兼容旧值）。
+
+### 10.2 通用检索 = 素材收集专家配置的技能编排
+
+- `ai-writing-researcher` agent 的 `config.yaml → skills` 是权威配置（智能体管理页可增删/替换）；种子默认 `[knowledge-base-search]`。
+- 内置技能 **knowledge-base-search（知识库检索）**：把原 web/intranet 关键词并发检索包装成技能。researcher 对它特殊处理——不拼 description，直接对 Step1 生成的检索词做原生并发检索（行为与旧 knowledge_base 模式一致）。其它配置技能按 `意图 + description` 拼定向 query 检索。按配置顺序执行、累积达 `max_materials` 早停（`stop_early`）。
+- 技能配置为空/全部失效 → 内存兜底回退知识库检索（`researcher._load_configured_skills`），检索永不瘫痪。
+- 种子：`_ai_writing_seed_assets/skills/knowledge-base-search/SKILL.md` → `skills/public/`（never-overwrite）；旧部署的 researcher `config.yaml` 缺 `skills` 键时就地补默认（显式 `skills: []` 不动）。`_ai_writing_seed.py::ensure_ai_writing_functional_agents()` 一并处理。
+
+### 10.3 PAUSE-1 输入框 → 匹配技能检索并**追加**
+
+- 用户在素材确认卡输入自然语言（如「检索 A 的数据」）→ `re_search + user_query`：配置技能 >1 个时 `SkillPicker(candidates=配置技能)` 让模型按输入匹配排序（流式打字机保留），单技能直接用；用用户原话（非知识库技能附 description）检索。
+- **追加语义**：保留原素材列表与顺序，新素材按 URL 去重后追加在末尾（ID 续号），跳过 LLM 重排与 max_materials 截断（仅 100 条硬上限），summary 显示「追加检索到 X 条新素材，当前共 Y 条」。原 20 条 + 新 20 条 = 40 条。
+- 「技能检索」独立按钮已删除（通用检索本来就走技能编排）；后端继续兼容旧 `enable_skill_search` action（按 user_query 追加处理）。无输入的「重新搜索」仍为覆盖式重检。
+- 前端：`InterventionCard.tsx`（按钮/文案，hasQuery 时按钮文案「检索并追加素材」）、`MaterialsToolbar.tsx`（提示语）、`useAIWritingStream.ts`（素材卡回到 researching 一律置 skillSearchPending，让 SkillStepsCard 占位即时挂载）。
+
+### 10.4 测试
+
+- `tests/test_ai_writing_material_source.py` 重写（9 例）：缺省/旧值→通用检索、自定义技能 description query、user_query 追加+URL 去重+多技能 picker 匹配（candidates 断言）、无输入重检覆盖、空配置回退。
+- `tests/test_ai_writing_seed.py` 扩展（+5 例）：技能资产存在、researcher 种子含默认 skills、技能种子 never-overwrite、缺 skills 键就地补丁、显式 `[]` 不动。

frontend-web/docs/ai-writing-对话驱动写作台-实现方案.md

@@ -0,0 +1,507 @@
+# AI 写作「对话驱动写作台」实现方案（可落地版）
+
+> 需求：**复制**现有 AI 写作代码，新增一个独立页面（**原页面/原路由零改动**）。在新页面里
+> **大改交互流程**——去掉「素材收集 / 大纲规划 / 作家写作 / 编辑审核」四个阶段干预卡里的**输入框**，
+> 只**保留原来的确认按钮**；在页面**底部新增一个统一的多行智能输入框**，具备**强意图理解**能力：
+> 重新搜索、新增检索词、添加检索素材、重新规划大纲、按要求改大纲、提修改意见、审核意见、
+> 素材不足继续搜集、对写作内容提问……**覆盖现有全部交互甚至更多**。
+>
+> 交互节奏不变：**一步一确认**——进行到某个专家阶段时，交互就针对该专家（阶段作用域）；
+> 用户可以**点原来的确认按钮**，也可以**在底部输入框里发「继续下一步」的意图**推进。
+> 意图**拿不准时**主动向用户**发起协助/澄清**，绝不盲目触发高代价动作（定稿 / 重搜等）。
+
+本文是**实现指引**，落地时按第 9 节路线图分阶段推进。文中所有文件路径、符号名均对齐当前代码。
+
+---
+
+## 1. 现状梳理（改造地基）
+
+现有 AI 写作是一套**独立 LangGraph 子系统**（不是 lead_agent），前后端都已成型、可复用。
+
+### 1.1 后端 `ai_writing` graph
+
+- 图工厂：`offline-backend-20260512/backend/packages/harness/deerflow/agents/ai_writing/graph.py`
+  （`make_ai_writing_graph`，registered as `assistant_id="ai_writing"`）
+- 状态：`.../ai_writing/state.py`（`AIWritingState`）
+- 四个「阶段大脑」节点：
+
+| 阶段 | 节点 | 文件 |
+|------|------|------|
+| 素材收集 | `researcher` | `nodes/researcher.py` |
+| 大纲规划 | `writer_outline` | `nodes/writer_outline.py` |
+| 作家写作 | `writer_draft` | `nodes/writer_draft.py` |
+| 编辑审核 | `editor` | `nodes/editor.py` |
+
+- **五个暂停点**（`interrupt()`，`Command(resume=payload)` 续跑）——这是对话改造的核心可复用资产：
+
+| pause_point | 语义 | 现有 action |
+|-------------|------|-------------|
+| `material_confirm` | 素材确认 | `confirm` / `re_search` / `enable_skill_search` |
+| `outline_confirm` | 大纲确认 | `confirm` / `re_outline` |
+| `draft_confirm` | 草稿确认 | `to_editor` / `finalize` / `user_revise` |
+| `review_confirm` | 编辑打回确认 | `accept_review` / `force_finalize` |
+| `section_help` | 素材不足求助 | `section_help`(+`sectionDecisions`) |
+
+- resume 载荷（`UserInterventionPayload`，`types/ai-writing.ts`）字段：`action`、`approvedMaterialIds`、
+  `userQuery`（自然语言补充检索）、`editedOutline`、`outlineFeedback`、`userRevisionNotes`、
+  `overrideVerdict`、`selectedIssueIndices`、`sectionDecisions`。
+  **协议已同时支持「自然语言 + 结构化 action」**——这是对话层能复用的关键。
+
+> 结论：**状态机 / 流式 / 暂停·续跑协议 / 持久化都可复用**，无需重写引擎。改造本质是
+> 「把分散在干预卡里的输入框，换成一个底部智能输入框 + 意图路由层」，再把意图翻译回**现有
+> `action + payload`**；仅少量新意图（对内容提问、素材不足自动回退重搜、追加审核意见）需新增能力。
+
+### 1.2 前端 `open-canvas` 子系统
+
+- 主页面：`frontend-web/src/open-canvas/pages/AIWritingPage.tsx`
+  - 路由注册：`open-canvas/routes/OpenCanvasRoutes.tsx`（`/page/canvas/ai-writing/*`）、
+    `pages/WorkspaceRoutes.tsx`（`/page/workspace/ai-writing/*`）、`pages/NotebookAIWritingPage.tsx`
+- 状态机 + 流式：`contexts/AIWritingContext.tsx`（`useReducer` + LangGraph `useStream`，`assistantId:'ai_writing'`）
+- 事件翻译 / reducer：`hooks/useAIWritingStream.ts`
+- 类型：`types/ai-writing.ts`
+- **左栏面板**：`components/ai-writing/AIWritingPanel.tsx`（时间线 + 干预卡 + 状态栏；idle 时挂启动表单）
+- **要改造的输入 UI**（本次重点）：
+  - 干预卡 `components/ai-writing/InterventionCard.tsx`：内含
+    `MaterialConfirmCard`（素材：有 `MaterialsToolbar` 输入框）、
+    `OutlineConfirmCard`（大纲：有 feedback textarea）、
+    `DraftConfirmCard`（草稿：有「修改意见」textarea）、
+    `ReviewConfirmCard`（审核：有「补充修改指令」textarea）、
+    `SectionHelpCard`（素材不足：按钮组）。
+    **每张卡里都既有输入框又有确认/动作按钮**——本次要**去掉输入框、保留按钮**。
+  - 启动表单 `components/ai-writing/AIWritingForm.tsx`（idle 阶段的配置表单）——本次由底部输入框接管启动。
+- **已存在的对话原型**（可借鉴）：`components/ai-writing/WritingSetupChat.tsx`
+  （`useThreadStream` 起 lead_agent 线程 + `setup_writing` 审批卡回填表单；仅管启动前配置，不直接复用）。
+- 底部输入框可直接复用 UI 组件：`@/components/ai-elements/prompt-input`
+  （`PromptInput` / `PromptInputTextarea` / `PromptInputSubmit` / `PromptInputFooter`，见 `WritingSetupChat`）。
+
+---
+
+## 2. 目标与范围
+
+### 2.1 必须满足
+
+1. **复制式新增**：新目录 / 新路由 / 新侧边栏入口，**旧页面、旧路由、旧组件零改动**（「初始的不用动」）。
+2. 页面**底部单一多行智能输入框**接管全流程交互；四个阶段干预卡里的**输入框全部移除**。
+3. **保留确认按钮**：每个阶段到达暂停点时，消息流里仍渲染**产物卡 + 原来的确认/动作按钮**
+   （素材「确认素材」、大纲「确认大纲」、草稿「让编辑审核 / 确认定稿」、审核「按编辑意见修改 / 强制定稿」、
+   素材不足的三选一按钮）。用户**点按钮**或**在底部输入框发自然语言意图**二选一均可推进。
+4. **强意图理解**：把用户自由文本准确路由到正确动作，**覆盖现有全部交互 + 更多**（见 3.2）。
+5. **阶段作用域**：意图解析必须知道「当前停在哪个专家阶段」，把同一句话按当前阶段翻译成对应 action。
+6. **素材不足自动回退重搜**：修改意见需要的信息现有素材没有时，先重搜补素材、补完自动继续原意图。
+7. **拿不准就协助**：低置信意图**不猜着执行**，走澄清追问（clarify）或用户协助。
+8. 保留右侧草稿实时预览（可编辑）与时间线 / 进度展示。
+
+### 2.2 明确不做（本期）
+
+- 不改旧 `AIWritingPage` 及其 `AIWritingForm` / `InterventionCard`（这两个是要在**副本**里改的）。
+- 不替换 `ai_writing` graph 四个阶段大脑逻辑，不动五个暂停点 / checkpoint / 持久化。
+- 不引新状态管理库（继续 `useReducer` + `useStream`）。
+
+### 2.3 复制策略（关键决策）
+
+「复制一份」= **复制会被大改的表现层组件**（页面 + 干预卡 + 面板），**复用不改的引擎层**：
+
+| 复制（新建副本，大改） | 复用（原样，不改；仅对 `types` 做**追加式**扩展） |
+|------------------------|--------------------------------------------------|
+| 新页面 `AIWritingChatPage.tsx` | `contexts/AIWritingContext.tsx`（状态机 + 流式） |
+| 新面板 `WritingChatPanel.tsx`（消息流 + 底部输入框） | `hooks/useAIWritingStream.ts`（事件 → state） |
+| 新消息卡 `chat-cards/*`（产物卡+确认按钮，**无输入框**） | `components/ai-writing/AIWritingDraftPanel.tsx`（右侧草稿预览） |
+| 新意图客户端 `api/ai-writing-intent.ts` | 各流式展示子组件（`MaterialsCard`/`OutlineCard`/`ReviewCard`/`SkillStepsCard`…） |
+| （可选）新 `contexts/WritingChatContext.tsx` 包一层「pending 意图 / 澄清态」 | `types/ai-writing.ts`（**只加字段不改旧字段**，保证旧页面不受影响） |
+
+> **不复用、也不改** 的三个「输入框组件」：`AIWritingForm` / `InterventionCard` / `WritingFormContext`——
+> 旧页面继续用它们，新页面完全不引用它们。这样「初始的不用动」得到硬保证。
+>
+> 为什么复用 `AIWritingContext` 而不复制它？它**不含任何输入框 UI**，只是「状态机 + 与后端 graph 的
+> 流式桥」，复用它**不会改动旧页面的任何呈现**（旧页面照常在自己的 Provider 实例里跑）。复用能显著
+> 降低维护成本、避免两套引擎漂移。若要绝对物理隔离，也可整目录复制 `AIWritingContext` +
+> `useAIWritingStream` 到新目录——**推荐先复用**，仅当后续需要给对话态加大量图内新协议时再分叉。
+
+---
+
+## 3. 核心设计
+
+### 3.1 三层结构
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│  对话 UI 层（新）  WritingChatPanel                             │
+│   - 消息流：用户消息 + AI 阶段产物卡（含【保留的确认按钮】）+ 进度   │
+│   - 底部：统一多行智能输入框（唯一自由输入入口）                    │
+│   - 右侧：草稿实时预览（复用 AIWritingDraftPanel）                │
+└───────────────┬──────────────────────────────────────────────┘
+                │ 用户自然语言（+ 当前 status/pausePoint 上下文）
+                ▼
+┌──────────────────────────────────────────────────────────────┐
+│  意图解析层（新，核心）  POST /api/ai-writing/sessions/{id}/intent │
+│   输出：{ intent, pausePoint, action, payload,                  │
+│          needResearch, researchQuery, answer, confidence, clarify }│
+└───────────────┬──────────────────────────────────────────────┘
+                │ 结构化 action + payload
+                ▼
+┌──────────────────────────────────────────────────────────────┐
+│  执行层（复用现有 AIWritingContext）                             │
+│   idle → startWriting(AIWritingRequest)                         │
+│   暂停 → submitIntervention(UserInterventionPayload)            │
+│   问答 → 旁路回答（不改写作状态）                                 │
+│   素材不足 → 先重搜、缓存 pending、补完自动续跑                     │
+└──────────────────────────────────────────────────────────────┘
+```
+
+**设计原则**：意图解析层是「翻译官」——把自由文本翻译成**执行层已经懂的指令**。能复用
+`action + payload` 的绝不新造协议；确认按钮点击**直接走执行层**（不经意图层，零延迟、零误判）。
+
+### 3.2 意图分类体系（覆盖全流程 + 更多）
+
+按「意图 → 触发时机（当前 status/pausePoint）→ 映射执行」组织，即意图解析引擎的目标 schema。
+**「甚至更多」** = G（问答）、H（控制）、以及 B/C/D/E 里的「素材不足自动回退重搜」。
+
+#### A. 启动类（status = `idle`）
+| 意图 | 用户说法示例 | 映射 |
+|------|-------------|------|
+| `start_writing` | 「写一篇关于新能源出口的深度分析，2000 字」 | 解析成 `AIWritingRequest` → `startWriting()` |
+| `start_with_outline` | 「按这个大纲写：…」 | `AIWritingRequest.userOutline` |
+| `start_imitate` | 「仿照这篇样文写…」 | `writingModeType='imitate'` + `sampleText` |
+
+#### B. 素材类（pausePoint = `material_confirm`）
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `confirm_materials` | 「素材可以，继续 / 下一步」 | `{action:'confirm', approvedMaterialIds}` |
+| `research_again` | 「重新搜索素材」 | `{action:'re_search'}`（无 userQuery=覆盖式重检） |
+| `add_material`/`add_keyword` | 「再补点关于 X 的素材」「加个关键词 Y」 | `{action:'re_search', userQuery:'X/Y'}`（追加） |
+| `select_materials` | 「只用第 1、3 条」 | `{action:'confirm', approvedMaterialIds:[…]}` |
+| `drop_materials` | 「去掉第 2 条」 | 同上（反选后的子集） |
+
+#### C. 大纲类（pausePoint = `outline_confirm`）
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `confirm_outline` | 「大纲 OK，开始写」 | `{action:'confirm'}` |
+| `reoutline` | 「重写大纲」 | `{action:'re_outline'}`（feedback 可空） |
+| `revise_outline` | 「第二章拆成两节」「调整顺序」 | `{action:'re_outline', outlineFeedback:自然语言}` |
+
+#### D. 写作 / 草稿类（pausePoint = `draft_confirm`）
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `to_editor` | 「交给编辑审核」 | `{action:'to_editor'}` |
+| `finalize` | 「就这样定稿」 | `{action:'finalize'}` **（高代价：低置信必澄清）** |
+| `revise_draft` | 「第三段太啰嗦，精简」「补个 2024 案例」 | `{action:'user_revise', userRevisionNotes:意见}` |
+| `rewrite_section` | 「重写第二章」 | `user_revise` + 章节定位写进 notes |
+| `change_tone/style` | 「更口语一点 / 更正式」 | `user_revise` + notes |
+| `apply_review`（若已有审核结果） | 「按编辑意见改」「只接受第 1、2 条」 | `{action:'user_revise', selectedIssueIndices:[…]}` |
+
+#### E. 编辑审核类（pausePoint = `review_confirm`）
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `accept_review` | 「按编辑意见改」 | `{action:'accept_review', selectedIssueIndices}` |
+| `partial_accept_review` | 「只接受第 1、2 条」 | `accept_review` + `selectedIssueIndices` 子集 |
+| `add_review_opinion` | 「再补一条：核查数据准确性」 | `accept_review` + `userRevisionNotes`（并入补充指令，现协议已支持） |
+| `force_finalize` | 「不改了，强制定稿」 | `{action:'force_finalize', overrideVerdict:true}` **（高代价：必澄清）** |
+
+#### F. 素材不足求助类（pausePoint = `section_help`）
+| 意图 | 映射 |
+|------|------|
+| `section_supplement` | `{action:'section_help', sectionDecisions:[…'supplement']}` |
+| `section_loose` | `sectionDecisions:[…'loose']` |
+| `section_delete` | `sectionDecisions:[…'delete']` |
+
+#### G. 问答类（**新**；任意 status；旁路，不改写作状态）
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `ask_about_content` | 「第二章讲了啥？」「为什么用这个论点？」 | 意图节点直接带回 `answer`，对话流渲染（见 5.4） |
+| `ask_meta` | 「现在到哪步了？」「用了哪些素材？」 | 读当前 state 直接回答，不走图 |
+
+#### H. 控制类（**新 / 半新**）
+| 意图 | 映射 |
+|------|------|
+| `next_step`（通用「继续/下一步」） | 按**当前 pausePoint** 映射到该阶段的默认确认（material/outline→`confirm`，draft→`to_editor`…；等价点确认按钮） |
+| `restart_stage` | 重跑当前阶段（复用 `resumeWriting()` 空 command 续跑） |
+| `run_background` | 转后台自动跑：`suspendAIWritingToBackground()` |
+| `cancel` | `pauseWriting()`（`stream.stop()`） |
+| `unknown/clarify` | 无法判定 → 反问澄清 / 用户协助（**防误触发硬指标**） |
+
+### 3.3 「素材不足自动重搜」判定与回退（用户强调点）
+
+触发：用户在**大纲/草稿/审核**阶段提出修改意见，但意见需要的信息现有素材里没有。
+
+判定来源（组合）：
+1. **意图节点直接判**：把「素材摘要（keywords + 每条 title/source）」喂给意图 prompt，让它判断
+   「这条意见能否用现有素材满足」；不能 → `needResearch=true` + `researchQuery`。
+2. **执行阶段兜底**：`writer_draft` 严格模式已有 `blocked_sections` → `section_help` 暂停点，
+   对话层把它翻译成「素材不足，是否重搜？」的追问。
+
+回退动作（**首期纯前端实现，不动后端协议**）：`needResearch=true` 时，前端把用户的修改
+`payload` 缓存为 `pendingIntent`，先 `submitIntervention({action:'re_search', userQuery:researchQuery})`
+补素材；监听到新一轮 `material_confirm`（素材追加完成）后，**自动提交** `pendingIntent`。
+需处理「重搜期间用户又改主意」→ 允许覆盖 pending。
+
+---
+
+## 4. 意图解析引擎：方案与契约
+
+**采用方案 A：后端 LLM 意图节点（独立 REST）**，叠加高频短句**规则快路径**优化。
+
+理由：`needResearch` 判定需要**完整写作上下文**（素材/大纲/草稿），后端天然持有 checkpoint state；
+与 `setup_writing` 一脉相承，离线模型选择策略统一；输出 schema 稳定、前端只消费。
+
+### 4.1 后端入口
+
+`app/gateway/routers/ai_writing.py` 新增：
+
+```
+POST /api/ai-writing/sessions/{session_id}/intent
+Body: { text: string, status: string, pausePoint?: string }
+Resp: IntentResult（见 4.3）
+```
+
+实现：读该 session 的 checkpoint state（素材摘要 / 大纲纲要 / 草稿字数·章节 / 审核意见）→
+用 `ai_writing` 配置模型（复用 `intent_parser.py` 同套 `create_chat_model` + `parse_json` +
+模型容错 `_model_fallback`）解析 → 返回结构化契约。**不改图拓扑**。
+
+新增 prompt：`agents/ai_writing/prompts/intent_router_prompts.py`
+- 输入：用户文本、`current_status`/`pause_point`、素材摘要、大纲纲要、草稿字数+章节标题、审核意见列表。
+- 输出：严格 JSON（4.3 契约）。硬要求：**只在证据充分时给高 confidence，否则给 `clarify`**；
+  `finalize`/`force_finalize`/`re_search` 等高代价意图**必须**高置信才不澄清。
+
+### 4.2 前端快路径（先跑规则，未命中再调后端）
+
+`api/ai-writing-intent.ts` 里对**当前 pausePoint** 做少量确定性短语命中，直接产出 payload，省一次往返：
+- 「继续/下一步/确认/可以/ok/好的」→ 当前阶段默认 `confirm`（draft 阶段=`to_editor`）。
+- 「重新搜索/重搜」（material）→ `re_search`。「重写大纲」（outline）→ `re_outline`。
+- 「定稿/强制定稿」→ **不进快路径**（高代价，一律走后端 + 可能澄清）。
+- 命中即执行；未命中 → 调后端 `intent` 接口。
+
+### 4.3 意图解析输出契约
+
+```jsonc
+{
+  "intent": "revise_draft",        // 见 3.2 分类
+  "pausePoint": "draft_confirm",   // 需要 resume 时；否则 null
+  "action": "user_revise",         // 映射到现有 action
+  "payload": {                     // 直接可喂 submitIntervention 的字段（camelCase）
+    "userRevisionNotes": "第三段精简，并补一个 2024 年的案例"
+  },
+  "needResearch": true,            // 素材是否不足
+  "researchQuery": "2024 行业案例", // needResearch 时的检索意图
+  "answer": null,                  // 问答类意图的直接回答（旁路）
+  "confidence": 0.86,
+  "clarify": null                  // 低置信时的反问话术（非空则不执行、只追问）
+}
+```
+
+前端消费顺序：
+1. `answer` 非空 → 对话流渲染回答（问答旁路，不动写作状态）。
+2. `clarify` 非空 **或** `confidence < 阈值(建议 0.6)` → 渲染反问气泡，等用户澄清（**防误触发**）。
+3. `needResearch=true` → 缓存 `pendingIntent=payload`，先重搜，收到新素材后自动提交。
+4. 否则 → `idle` 走 `startWriting(...)`；暂停态走 `submitIntervention({action, ...payload})`。
+
+---
+
+## 5. 前端改造方案
+
+### 5.1 新页面与路由（复制式）
+
+- 新页面：`open-canvas/pages/AIWritingChatPage.tsx`
+  （骨架照抄 `AIWritingPage.tsx` 的 Provider 包裹与左右分栏；左栏换成 `WritingChatPanel`，右栏仍
+  `AIWritingDraftPanel`；idle 不再挂 `AIWritingForm`，改由底部输入框启动）。
+- 路由注册（**新增，不动旧行**）：
+  - `open-canvas/routes/OpenCanvasRoutes.tsx` 加 `path="ai-writing-chat/*"`。
+  - 侧边栏 `core/page-layout/sidebar-menu.ts`：在 `qa-research` 旁新增
+    `{ id:"qa-research-chat", label:"AI写作(对话版)", icon:FileText, path:"/page/canvas/ai-writing-chat" }`。
+    （或先不加、内部灰度直链验证。）
+
+### 5.2 新面板 `WritingChatPanel.tsx`（左栏主体）
+
+职责 = 消息流容器 + 底部输入框，替代 `AIWritingPanel` 里的「时间线 + InterventionCard + 状态栏」。
+复用 `useAIWriting()` 读 state / 调 `startWriting` / `submitIntervention` / `pauseWriting` /
+`suspendAIWritingToBackground`。
+
+消息流渲染（把 `ProgressEvent` / 阶段产物适配成消息卡，复用现有展示子组件）：
+- 运行中：`research_progress`/`outline_chunk`/`draft_chunk`/`review_chunk` → 进度 / 流式卡
+  （复用 `SkillStepsCard`/`OutlineStreamingView`/`DraftGeneratingView`/`ReviewStreamingView` 的展示部分）。
+- 到达暂停点：渲染 **产物卡 + 保留的确认按钮**（见 5.3），不再有输入框。
+- 用户消息、AI 澄清追问、问答回答：普通气泡。
+
+底部输入框：直接复用 `@/components/ai-elements/prompt-input`（`PromptInput`+`PromptInputTextarea`+
+`PromptInputSubmit`），Enter 发送、Shift+Enter 换行；发送时读当前 `state.status`/`currentPause?.pausePoint`
+交给意图路由（见 5.5）。运行中（非暂停点）可禁用发送或转「排队/提示当前在生成」。
+
+### 5.3 新消息卡 `chat-cards/*`（**保留按钮、去掉输入框**）
+
+把 `InterventionCard.tsx` 的五张卡各复制一份到 `open-canvas/components/ai-writing-chat/chat-cards/`，
+**删掉其中的 textarea / MaterialsToolbar 输入部分，保留产物展示 + 确认/动作按钮**：
+
+| 新卡 | 展示（复用） | 保留的按钮 | 删除的输入 |
+|------|-------------|-----------|-----------|
+| `MaterialConfirmChatCard` | `MaterialsCard`（勾选保留）+ `SkillStepsCard` | 「确认素材，规划大纲」「重新搜索」 | `MaterialsToolbar` 的 userQuery 输入框 |
+| `OutlineConfirmChatCard` | `OutlineCard`（可点标题微调保留） | 「确认大纲，开始写作」 | feedback textarea + 发送 |
+| `DraftConfirmChatCard` | `ReviewCard`（若有审核，勾选保留） | 「按编辑审核意见修改」「让编辑继续审核」「确认定稿」 | 「修改意见」textarea |
+| `ReviewConfirmChatCard` | `ReviewCard`（勾选保留） | 「按编辑意见修改」「强制定稿」 | 「补充修改指令」textarea |
+| `SectionHelpChatCard` | 章节 + 三选一按钮组 | 三选一 + 「提交并继续」 | （本就无自由输入，原样保留） |
+
+> 勾选态（素材/审核意见）**保留**——它是「点按钮」路径的一部分，不算自由输入框。用户想用自然语言
+> 「只用第 1、3 条」也能走底部输入框（意图层产出 `approvedMaterialIds`/`selectedIssueIndices`）。
+> 按钮点击 **直接调 `submitIntervention`**，与旧卡完全一致，零改动风险。
+
+### 5.4 问答旁路（新能力）
+
+「对写作内容提问」不改写作 state。首期**轻量实现**：意图节点检出 `ask_*` 时读 state 直接带回 `answer`，
+前端在消息流渲染为普通 AI 气泡即可（一次调用出答案）。完整版（后续）可另起只读 lead_agent 线程注入
+草稿/大纲作背景，类似 `WritingSetupChat` 的 `useThreadStream`。
+
+### 5.5 交互流程（对话版）串起来
+
+1. **空闲**：底部输入「写一篇关于 X 的深度分析，2000 字」→ 意图 `start_writing` → 组 `AIWritingRequest`
+   → `startWriting()`。（缺关键字段时先 `clarify` 追问字数/读者/类型。）
+2. **运行中**：进度/流式卡渲染。
+3. **到暂停点**：渲染产物卡 + 按钮 + 一句提示「你可以点上面的按钮，或直接说：确认继续 / 补充素材 / 改大纲…」。
+   - **点按钮** → 直接 `submitIntervention`（旧逻辑）。
+   - **发文字** → `resolveIntent(text, status, pausePoint)`（先快路径、后后端）→ 按 4.3 消费。
+4. **问答**：任意时刻提问 → 旁路 `answer`，不打断写作。
+5. **素材不足**：`needResearch` 或 `section_help` → 追问/执行「重搜 → 自动续跑 pending 意图」。
+6. **拿不准**：`clarify`/低置信 → 反问气泡，不执行。
+
+### 5.6 pending 意图 & 澄清态（新增本地状态）
+
+在 `WritingChatPanel`（或新 `WritingChatContext`）维护：
+- `pendingIntent: UserInterventionPayload | null` —— 素材不足重搜完成后自动提交。
+- `awaitingClarify: { originalText: string } | null` —— 澄清态，用户下一句与上一句拼接再解析。
+- pending 生命周期：设置 → 提交 `re_search` → 监听 reducer 里新一轮 `awaiting_material_confirm`
+  （`state.status` 从 `researching` 回到 `awaiting_material_confirm`）→ 自动 `submitIntervention(pending)` → 清空。
+
+---
+
+## 6. 后端改造方案
+
+### 6.1 意图解析入口（新增，唯一后端改动主体）
+
+- `app/gateway/routers/ai_writing.py`：新增 `POST /sessions/{id}/intent`（见 4.1）。
+  读 checkpoint state 用 `app.state.checkpointer` + `make_ai_writing_graph().aget_state(...)`
+  （参照 `ai_writing_job_executor.py` 的读法）取素材/大纲/草稿/审核摘要。
+- `agents/ai_writing/prompts/intent_router_prompts.py`：新增意图 prompt（见 4.1）。
+- 复用 `nodes/intent_parser.py` 的模型创建 / `parse_json` / `_model_fallback` 容错。
+
+### 6.2 不需要改的部分
+
+- 四个阶段大脑节点、五个暂停点、checkpoint、StreamBridge、持久化、sessions/transcript REST——**全不动**。
+- 「素材不足自动续跑」「问答旁路」首期都在**前端 / 意图节点**实现，**不扩 resume 协议**。
+
+### 6.3 可选增强（阶段 3，按需）
+
+- `add_review_opinion` 完整版：`review_confirm` resume 增字段 `extra_review_notes`（首期已用现有
+  `userRevisionNotes` 降级承载，够用）。
+- `resume_intent` 后端化（把「重搜完自动续跑」搬到后端，减少前端状态机复杂度）。
+- undo / 回退到上一暂停点（依赖 checkpoint 回滚）。
+
+---
+
+## 7. 数据流时序（改稿 + 素材不足自动重搜）
+
+```
+用户（draft_confirm 暂停）: "第三段补个2024年的行业案例"
+  │ 底部输入框 → resolveIntent(text, status='awaiting_draft_confirm', pausePoint='draft_confirm')
+  ▼ POST /api/ai-writing/sessions/{id}/intent { text, status, pausePoint }
+后端: 读 state(素材摘要) + LLM 解析
+  │ 返回 { intent:revise_draft, action:user_revise,
+  │        payload:{userRevisionNotes:"第三段…补2024案例"},
+  │        needResearch:true, researchQuery:"2024 行业案例", confidence:0.9 }
+  ▼
+前端: needResearch=true → pendingIntent = payload
+  │ submitIntervention({action:'re_search', userQuery:"2024 行业案例"})
+  ▼ LangGraph resume → researcher 追加素材 → status 回到 awaiting_material_confirm
+前端: 监听到新一轮素材确认 → 自动提交 pendingIntent
+  │ submitIntervention({action:'user_revise', userRevisionNotes:"第三段…补2024案例"})
+  ▼ writer_draft 用新素材改稿 → draft_chunk… → draft_ready → draft_confirm
+前端: 消息流展示新草稿卡 + "已按你的意见改写并补充了 2024 案例"
+```
+
+---
+
+## 8. 关键实现细节与坑
+
+1. **阶段作用域**：`resolveIntent` 必须带 `state.currentPause?.pausePoint` + `state.status`——
+   同一句「重新来」在 material 是重搜、在 outline 是重写大纲。`AIWritingContext` 已有这两个字段，直接读。
+2. **确认按钮零改动**：新卡的按钮 `onClick` 原样调 `submitIntervention(payload)`，与旧卡逐字一致，
+   风险最低；**只删输入框**。
+3. **防误触发**：低置信（<0.6）或 `clarify` 非空一律追问；`finalize`/`force_finalize`/`re_search`
+   即使命中也要求高置信，否则澄清。绝不盲目定稿/覆盖重搜。
+4. **pending 意图队列**：素材不足是「先插重搜、再回原意图」，用 5.6 的小状态机；重搜完成前允许覆盖 pending。
+5. **问答不污染 transcript**：问答/澄清消息在前端标记 `kind:'qa'|'clarify'`，与写作进度事件区分（
+   `AIWritingContext` 的 transcript 只存 progressEvents/completedInterventions，问答气泡是纯前端消息，
+   默认不入 transcript，避免历史回看错乱）。
+6. **流式产物→消息卡**：复用 `OutlineStreamingView`/`DraftGeneratingView`/`ReviewStreamingView`/
+   `SkillStepsCard` 的**展示部分**，套进消息容器，不重写渲染。
+7. **右侧草稿预览**：`AIWritingDraftPanel` + `DraftSync` 原样复用（`DraftSync` 依据 status/markdown
+   同步右侧画布）。
+8. **离线内网**：意图模型走 `config.yaml → ai_writing` 配置模型；检索仍走技能/内网 ES，不联网。
+9. **模型选择透传**：`submitIntervention` 的 resume 已把 `state.request?.modelName` 一并回传（见
+   `AIWritingContext`），新页面沿用即可。
+10. **旧页面隔离验证**：改完后回归旧 `/page/canvas/ai-writing` 与 `/page/workspace/ai-writing`、
+    笔记本嵌入页，确认零变化（新代码不 import 旧的 `AIWritingForm`/`InterventionCard`/`WritingFormContext`）。
+
+---
+
+## 9. 分阶段实施路线图
+
+**阶段 0 — 骨架（不含意图）**
+- 复制 `AIWritingChatPage` + 注册新路由 + 侧边栏入口；复用 `AIWritingContext`/`useStream`/`DraftPanel`。
+- 复制五张 `chat-cards`（删输入框、留按钮）；底部输入框先只做 idle 直发 `start_writing`
+  （文本原样当 `userIntent`，其余字段取默认）+ 暂停点靠按钮推进。端到端跑通。
+
+**阶段 1 — 意图解析（核心）**
+- 后端 `POST /sessions/{id}/intent` + `intent_router_prompts.py`，返回 4.3 契约。
+- 前端 `api/ai-writing-intent.ts`（快路径 + 后端）接入 `WritingChatPanel`，覆盖 A~F 类意图。
+- 低置信 `clarify` 澄清态（5.6）。
+
+**阶段 2 — 问答旁路 + 素材不足自动重搜**
+- G 类问答（意图节点直接带 `answer`）。
+- `needResearch` + pending 意图机制（前端实现重搜后自动续跑，5.6）。
+
+**阶段 3 — 增强（按需）**
+- `add_review_opinion` 扩协议、`resume_intent` 后端化、undo/回退、完整问答只读线程。
+
+**阶段 4 — 打磨**
+- 消息卡视觉、历史回看（transcript）、后台挂起入口、灰度到侧边栏。
+
+---
+
+## 10. 关键文件清单（落地对照）
+
+### 新增（前端）
+- `open-canvas/pages/AIWritingChatPage.tsx` — 新页面（复制 `AIWritingPage` 骨架改造）
+- `open-canvas/components/ai-writing-chat/WritingChatPanel.tsx` — 消息流 + 底部输入框
+- `open-canvas/components/ai-writing-chat/chat-cards/{MaterialConfirmChatCard,OutlineConfirmChatCard,DraftConfirmChatCard,ReviewConfirmChatCard,SectionHelpChatCard}.tsx` — 保留按钮、去掉输入框
+- `open-canvas/components/ai-writing-chat/progressToMessage.ts` — `ProgressEvent` → 消息卡适配
+- `open-canvas/api/ai-writing-intent.ts` — 意图解析客户端（快路径 + `POST …/intent`）
+- （可选）`open-canvas/contexts/WritingChatContext.tsx` — pending 意图 / 澄清态
+
+### 修改（前端，仅追加，不动旧逻辑）
+- `open-canvas/routes/OpenCanvasRoutes.tsx` — 加一条 `ai-writing-chat/*` 路由
+- `core/page-layout/sidebar-menu.ts` — 加一个侧边栏入口（可选）
+- `open-canvas/types/ai-writing.ts` — **仅追加** `IntentResult` 等新类型，不改旧字段
+
+### 新增（后端）
+- `app/gateway/routers/ai_writing.py` — 加 `POST /sessions/{id}/intent`
+- `agents/ai_writing/prompts/intent_router_prompts.py` — 意图 prompt
+- `tests/test_ai_writing_intent.py` — 意图接口单测（TDD 强制）
+
+### 复用（不改）
+- `open-canvas/contexts/AIWritingContext.tsx`、`hooks/useAIWritingStream.ts`
+- `open-canvas/components/ai-writing/{AIWritingDraftPanel,DraftSync,MaterialsCard,OutlineCard,ReviewCard,SkillStepsCard,OutlineStreamingView,DraftGeneratingView,ReviewStreamingView}.tsx`
+- `agents/ai_writing/graph.py`、四个阶段节点、五个暂停点、`nodes/intent_parser.py`
+
+### 绝不动（保证「初始的不用动」）
+- `open-canvas/pages/AIWritingPage.tsx` 及其引用的
+  `components/ai-writing/{AIWritingForm,InterventionCard}.tsx`、`contexts/WritingFormContext.tsx`
+- 旧路由 `/page/canvas/ai-writing`、`/page/workspace/ai-writing`、笔记本嵌入页
+
+---
+
+## 11. 待确认（默认取值已给出，可直接推进）
+
+1. 意图引擎：**后端 LLM 节点（方案 A）+ 前端短句快路径** —— 默认采用。
+2. `AIWritingContext` / `useAIWritingStream`：**复用**（不物理复制）——默认采用；需绝对隔离可改为复制。
+3. 新页面入口：**侧边栏新增「AI写作(对话版)」** —— 默认加；若要先灰度可只留直链。
+4. 「素材不足自动重搜」：**首期前端 pending 续跑**（不动后端 resume 协议）——默认采用。
+5. 问答旁路：**首期意图节点直接带 `answer`** —— 默认采用。
+
+> 以上默认按「A + 复用引擎 + 侧边栏入口 + 前端 pending + 意图节点带答案」推进，如需调整请指出。

frontend-web/docs/ai-writing-对话驱动改造方案.md

@@ -0,0 +1,454 @@
+# AI 写作「对话驱动 + 意图解析」改造方案
+
+> 目标：在**不动现有 AI 写作页面**的前提下，新建一个「对话驱动」的写作工作台。
+> 去掉素材收集 / 大纲规划 / 作家写作 / 编辑审核各阶段**分散的输入框/表单**，
+> 用**底部一个统一的智能输入框**接管全流程交互；该输入框具备**强意图解析**能力，
+> 能准确识别用户意图（重新搜索、加素材、加关键词、重写大纲、按要求改大纲、改写作、
+> 改编辑、提编辑意见、对写作内容提问……），并在**素材不足**时自动回退去重新检索素材。
+
+本文只做**方案与实现指引**，不含代码改动。落地时按第 9 节的路线图分阶段推进。
+
+---
+
+## 1. 现状梳理（改造的地基）
+
+现有 AI 写作是一套**独立的 LangGraph 子系统**（不是 lead_agent），前后端都已成型。
+
+### 1.1 后端：`ai_writing` graph
+
+- 图工厂：`offline-backend-20260512/backend/packages/harness/deerflow/agents/ai_writing/graph.py`
+- 状态：`.../agents/ai_writing/state.py`（`AIWritingState` + `UserInterventionPayload`）
+- 注册：`offline-backend-20260512/backend/langgraph.json` → `assistant_id = "ai_writing"`
+- 执行：与 lead agent **共用** RunManager + StreamBridge + checkpointer（`app/gateway/services.py` 里 `assistant_id=="ai_writing"` 分发到 `make_ai_writing_graph`）
+
+节点拓扑（实际）：
+
+```
+sample_analyzer → intent_parser → researcher
+  → [cond] pause_material | writer_draft
+  → writer_outline → pause_outline
+  → writer_draft → [cond] pause_section_help | pause_draft | END
+  → editor → [cond] pause_draft | pause_review
+  → pause_review → END | writer_draft
+```
+
+四个「阶段大脑」节点：
+
+| 阶段 | 节点 | 文件 |
+|------|------|------|
+| 素材收集 | `researcher` | `nodes/researcher.py` |
+| 大纲规划 | `writer_outline` | `nodes/writer_outline.py` |
+| 作家写作 | `writer_draft` | `nodes/writer_draft.py` |
+| 编辑审核 | `editor` | `nodes/editor.py` |
+
+五个**暂停点**（`interrupt()`，靠 `Command(resume=payload)` 续跑）：
+
+| pause_point | 语义 | 可用 action（现有） |
+|-------------|------|---------------------|
+| `material_confirm` | 素材确认 | `confirm` / `re_search` / `supplement_search` / `enable_skill_search` |
+| `outline_confirm` | 大纲确认 | `confirm` / `re_outline` |
+| `draft_confirm` | 草稿确认 | `to_editor` / `finalize` / `user_revise` / `custom_revise` |
+| `review_confirm` | 编辑打回确认 | `accept_review` / `force_finalize` |
+| `section_help` | 素材不足求助 | `supplement` / `loose` / `delete` |
+
+> resume 载荷字段（`UserInterventionPayload`）：`action`、`approved_material_ids`、
+> `extra_keywords`、`user_query`(自然语言补充检索)、`edited_outline`、`outline_feedback`、
+> `user_revision_notes`、`override_verdict`、`selected_issue_indices`、`section_decisions`。
+> **关键点**：现有协议已经支持「自然语言 + 结构化 action」，这是对话改造的核心可复用资产。
+
+REST（业务元数据，非图执行）：`app/gateway/routers/ai_writing.py`，前缀 `/api/ai-writing`
+（sessions CRUD、transcript 保存、article-types、后台挂起 `/background` + `/progress` 等）。
+
+持久化：`ai_writing_sessions` 表（`transcript` 为 `PortableLongText`）
++ `ai_writing_article_types`（`deerflow/persistence/...`）。
+
+配置：`config.yaml → ai_writing`（`keyword_model`、`rank_model`、`max_materials`、
+`use_builtin_agents.{researcher,outliner,writer,editor}` 等）。
+
+### 1.2 前端：`open-canvas` 子系统
+
+- 主页面：`frontend-web/src/open-canvas/pages/AIWritingPage.tsx`
+- 路由：`/page/canvas/ai-writing`、`/page/workspace/ai-writing`
+- 状态机：`contexts/AIWritingContext.tsx`（`useReducer` + LangGraph `useStream`）
+- 事件翻译/reducer：`hooks/useAIWritingStream.ts`
+- 类型：`types/ai-writing.ts`（`WritingStatus`、`ProgressEvent`、`UserInterventionPayload`、`AIWritingRequest`…）
+- 流式：LangGraph `useStream`，`assistantId: 'ai_writing'`，`streamMode: ['values','updates','custom','messages-tuple']`
+- **要去掉的输入 UI**（改造重点）：
+  - 启动表单 `components/ai-writing/AIWritingForm.tsx` + `WritingFormContext`
+  - 阶段暂停输入 `components/ai-writing/InterventionCard.tsx`（素材/大纲/草稿/审核四套内嵌表单）
+- **已存在的对话原型**：`components/ai-writing/WritingSetupChat.tsx`
+  （用 `useThreadStream` 起一条 lead_agent 线程 + `setup_writing` 工具审批卡回填表单）——
+  这是「对话 → 结构化配置」的现成范式，可借鉴但**不直接复用**（它只管启动前配置）。
+
+### 1.3 结论
+
+- **状态机、流式、暂停/续跑协议、持久化都可复用**，无需重写引擎。
+- 改造本质 = **把「分散表单」换成「一个对话输入框 + 意图路由层」**，
+  再把意图映射回**现有的 `action + payload`**（大部分场景），
+  少量新意图（如「对内容提问」「素材不足自动重搜」）需要**新增协议/节点**。
+
+---
+
+## 2. 目标与范围
+
+### 2.1 必须满足
+
+1. 新页面/新路由，**旧页面零改动**（用户要求「初始的不用动」）。
+2. 底部**单一对话输入框**控制所有阶段交互，移除各阶段独立输入框。
+3. **强意图解析**：准确识别用户自然语言意图并路由到正确动作，覆盖全流程 + 更多。
+4. 用户给修改意见后，**若现有素材不足以满足要求 → 自动/建议重新检索素材**再继续。
+5. 保留右侧草稿实时预览（可编辑）与时间线/进度展示。
+
+### 2.2 明确不做（本期）
+
+- 不改旧 `AIWritingPage` 及其表单/干预卡组件。
+- 不替换底层 `ai_writing` graph 的四个阶段大脑逻辑（只加意图层与少量新协议）。
+- 不引入新的状态管理库（继续 `useReducer` + `useStream`）。
+
+---
+
+## 3. 核心设计
+
+### 3.1 总体思路：三层结构
+
+```
+┌─────────────────────────────────────────────────────────┐
+│  对话 UI 层（新）                                          │
+│  - 左：消息流（用户消息 + AI 阶段产物卡片 + 进度）          │
+│  - 底：统一智能输入框（唯一交互入口）                       │
+│  - 右：草稿实时预览（复用 AIWritingDraftPanel）            │
+└───────────────┬─────────────────────────────────────────┘
+                │ 用户自然语言
+                ▼
+┌─────────────────────────────────────────────────────────┐
+│  意图解析层（新，核心）                                    │
+│  - 输入：用户文本 + 当前 WritingStatus + 上下文快照        │
+│  - 输出：{ intent, action, payload, needResearch, ... }   │
+└───────────────┬─────────────────────────────────────────┘
+                │ 结构化 action + payload
+                ▼
+┌─────────────────────────────────────────────────────────┐
+│  执行层（复用现有）                                        │
+│  - 空闲态：startWriting(AIWritingRequest)                  │
+│  - 暂停态：submitIntervention(UserInterventionPayload)     │
+│  - 运行中：stream.stop() → 续跑 / 新命令                    │
+│  - 提问态：旁路问答（不改写作状态）                        │
+└─────────────────────────────────────────────────────────┘
+```
+
+**设计原则**：意图解析层是「翻译官」——把自由文本翻译成**现有执行层已经懂的指令**。
+能复用 `action + payload` 的绝不新造协议；只有现有协议表达不了的才扩展。
+
+### 3.2 意图分类体系（覆盖用户全流程 + 更多）
+
+按「意图类别 → 触发时机（当前 status）→ 映射到的执行」组织。这是**意图解析引擎的目标 schema**。
+
+#### A. 启动类（status = idle）
+
+| 意图 | 说明 | 映射 |
+|------|------|------|
+| `start_writing` | 用户描述要写什么 | 解析成 `AIWritingRequest` → `startWriting()` |
+| `start_with_outline` | 用户自带大纲 | `AIWritingRequest.userOutline` |
+| `start_imitate` | 样文仿写 | `writingModeType=imitate` + 样文 |
+
+#### B. 素材类（status ≈ awaiting_material_confirm / 运行中）
+
+| 意图 | 用户说法示例 | 映射 |
+|------|-------------|------|
+| `confirm_materials` | 「素材可以，继续」 | `material_confirm` + `confirm`（可带勾选 ids） |
+| `research_again` | 「重新搜索素材」 | `material_confirm` + `re_search` |
+| `add_material` / `add_keyword` | 「补充关于 X 的素材」「加个关键词 Y」 | `material_confirm` + `supplement_search`，`user_query`=X/Y |
+| `use_skill_search` | 「用 XX 技能查」 | `material_confirm` + `enable_skill_search`，`user_query`=技能/来源 |
+| `select_materials` | 「只用第 1、3 条」 | `confirm` + `approved_material_ids` 子集 |
+| `drop_materials` | 「去掉第 2 条」 | 同上，反选后 `approved_material_ids` |
+
+#### C. 大纲类（status ≈ awaiting_outline_confirm）
+
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `confirm_outline` | 「大纲 OK」 | `outline_confirm` + `confirm` |
+| `reoutline` | 「重写大纲」 | `outline_confirm` + `re_outline`（`outline_feedback` 可空） |
+| `revise_outline` | 「第二章拆成两节」「调整顺序」 | `re_outline` + `outline_feedback`=自然语言 |
+| `edit_outline_manually` | 用户直接给出新大纲文本 | 解析成 `edited_outline` |
+
+#### D. 写作/草稿类（status ≈ awaiting_draft_confirm / writing_draft）
+
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `to_editor` | 「交给编辑审核」 | `draft_confirm` + `to_editor` |
+| `finalize` | 「就这样定稿」 | `draft_confirm` + `finalize` |
+| `revise_draft` | 「第三段太啰嗦，精简」「补个案例」 | `draft_confirm` + `user_revise`，`user_revision_notes`=意见 |
+| `rewrite_section` | 「重写第二章」 | `user_revise` + 定位信息（章节）写进 notes |
+| `change_tone/style` | 「更口语一点」 | `user_revise` + notes |
+
+#### E. 编辑审核类（status ≈ awaiting_review_confirm）
+
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `accept_review` | 「按编辑意见改」 | `review_confirm` + `accept_review`（可带 `selected_issue_indices`） |
+| `partial_accept_review` | 「只接受第 1、2 条意见」 | `accept_review` + `selected_issue_indices` |
+| `force_finalize` | 「不改了，强制定稿」 | `review_confirm` + `force_finalize` |
+| `add_review_opinion` | 「你再补一条：检查数据准确性」 | 追加自定义审核意见（见 5.3 扩展） |
+
+#### F. 素材不足求助类（status = awaiting_section_help）
+
+| 意图 | 映射 |
+|------|------|
+| `section_supplement` | `section_help` + `supplement`（去重搜） |
+| `section_loose` | `section_help` + `loose`（放宽续写） |
+| `section_delete` | `section_help` + `delete` |
+
+#### G. 问答类（**新**，任意 status，旁路，不改写作状态）
+
+| 意图 | 示例 | 映射 |
+|------|------|------|
+| `ask_about_content` | 「第二章讲了啥？」「为什么用这个论点？」 | 旁路问答（见 5.4） |
+| `ask_meta` | 「现在进行到哪一步？」「用了哪些素材？」 | 读当前 state 直接回答，不走图 |
+
+#### H. 控制类（**新/半新**）
+
+| 意图 | 映射 |
+|------|------|
+| `undo/back` | 回退到上一暂停点（依赖 checkpoint 回滚，见 8.4） |
+| `restart_stage` | 重跑当前阶段 |
+| `run_background` | 挂起后台自动跑 → `POST /sessions/{id}/background` |
+| `cancel` | `stream.stop()` |
+| `unknown/clarify` | 无法判定 → 反问澄清（对话追问，不误触发） |
+
+> **覆盖「甚至更多」**：G（问答）、H（控制）、以及 D/E 里「素材不足自动回退重搜」都是超出原表单能力的新增。
+
+### 3.3 「素材不足自动重搜」的判定与回退（用户强调的重点）
+
+触发场景：用户在**大纲/草稿/审核**阶段提出修改意见，但意见需要的**信息现有素材里没有**。
+
+判定放在**意图解析层**输出一个 `needResearch: boolean` + `researchQuery`，判定来源二选一（推荐组合）：
+
+1. **意图解析 LLM 直接判断**：把「当前素材摘要（keywords + 每条 title/来源）」喂给意图解析
+   prompt，让它判断「用户这条意见能否用现有素材满足」。不能 → `needResearch=true` 并给出检索词。
+2. **执行阶段兜底**：`writer_draft` 严格模式本就有 `blocked_sections` → `pause_section_help`，
+   这是**已有的**素材不足闸门；对话层把它翻译成「素材不足，是否重新检索？」的对话追问。
+
+回退动作：`needResearch=true` 时，先走 `material_confirm + supplement_search`（或新的
+「带目标的重搜」协议，见 8.3）补素材，**补完自动继续**用户原本的修改意图（需要在对话层
+记住「pending 修改意图」，重搜结束后再提交）。
+
+---
+
+## 4. 意图解析引擎：方案对比与推荐
+
+| 方案 | 做法 | 优点 | 缺点 |
+|------|------|------|------|
+| **A. 后端 LLM 意图节点**（推荐） | 新增 `/api/ai-writing/intent/parse`（或图内新节点），后端用 LLM 把 `{text, status, contextSnapshot}` → 结构化意图 JSON | 能吃到完整 state（素材/大纲/草稿）；可判 `needResearch`；prompt/模型集中可控；离线内网可用配置模型 | 多一次网络往返（可接受，交互本就等待） |
+| B. 前端调模型接口分类 | 前端直接调现有 `/api/models` 聊天做分类 | 少一层后端改动 | 前端难拿全后端 state 快照；prompt 分散；鉴权/模型选择复杂 |
+| C. 规则 + LLM 混合 | 常见短句走关键词规则快路径，兜底 LLM | 快、省 token | 规则易漏、维护成本高；中文表达多样命中率低 |
+
+**推荐 A（后端 LLM 意图节点）**，并在其上**叠加 C 的快路径**做优化（如「确认/继续/定稿」等
+高频短句先走轻量规则，未命中再调 LLM）。理由：
+
+- 意图判定需要**当前写作上下文**（尤其 `needResearch` 判定），后端天然持有 state/checkpoint。
+- 与现有「配置助手 `setup_writing`」一脉相承，模型选择/离线部署策略统一。
+- 输出 schema 稳定，前端只消费结构化结果，UI 简单。
+
+### 4.1 意图解析输出契约（建议）
+
+```jsonc
+{
+  "intent": "revise_draft",          // 见第 3.2 分类
+  "pausePoint": "draft_confirm",     // 若需 resume；否则 null
+  "action": "user_revise",           // 映射到现有 action；新意图可为新值
+  "payload": {                        // 直接可喂 submitIntervention 的字段
+    "userRevisionNotes": "第三段精简，并补一个 2024 年的案例"
+  },
+  "needResearch": true,               // 素材是否不足
+  "researchQuery": "2024 行业案例",   // needResearch 时的检索意图
+  "answer": null,                     // 问答类意图的直接回答（旁路）
+  "confidence": 0.86,
+  "clarify": null                     // 低置信时的反问话术
+}
+```
+
+前端拿到后：
+- `answer` 非空 → 直接在对话流渲染回答（问答旁路，不动写作状态）。
+- `clarify` 非空或 `confidence` 低 → 渲染反问，等用户澄清（**防误触发**）。
+- `needResearch=true` → 先重搜，缓存 `payload` 为 pending，重搜完再提交。
+- 否则 → `submitIntervention({action, ...payload})` 或 `startWriting(...)`。
+
+---
+
+## 5. 前端改造方案
+
+### 5.1 新页面与路由
+
+- 新目录：`frontend-web/src/open-canvas/pages/AIWritingChatPage.tsx`（或 `conversational/` 子目录）。
+- 新路由：`/page/canvas/ai-writing-chat`（在 `OpenCanvasRoutes.tsx` 注册；旧路由保留）。
+- 侧边栏：`sidebar-menu.ts` 加一个入口（如「AI 写作（对话版）」），或先不加、内部灰度。
+
+### 5.2 复用 vs 新建
+
+| 复用（尽量不改） | 新建 |
+|------------------|------|
+| `AIWritingContext` / `useAIWritingStream`（状态机 + 流式） | 统一对话输入框组件 `WritingChatComposer` |
+| `AIWritingDraftPanel`（右侧草稿预览） | 消息流容器 `WritingChatThread`（渲染阶段产物为消息卡片） |
+| `types/ai-writing.ts`（按需扩展） | 意图解析客户端 `api/ai-writing-intent.ts` |
+| `ProgressEvent` 事件模型 | 阶段产物 → 消息卡片的适配器 `progressToMessage.ts` |
+| 会话持久化 REST | 「pending 意图」暂存逻辑（重搜后续跑） |
+
+**不复用**：`AIWritingForm` / `WritingFormContext` / `InterventionCard`（这三个就是要去掉的表单）。
+
+### 5.3 交互流程（对话版）
+
+1. 空闲：用户在底部输入「写一篇关于 X 的深度分析，2000 字」→ 意图解析 `start_writing`
+   → 组装 `AIWritingRequest` → `startWriting()`。
+2. 运行中：`ProgressEvent`（`research_progress`/`outline_chunk`/`draft_chunk`…）
+   → 适配成消息流里的**进度卡片/流式卡片**（复用现有流式视图组件的展示部分）。
+3. 到达暂停点：不再弹 `InterventionCard`，而是在消息流里展示**阶段产物卡片**
+   （素材列表 / 大纲 / 草稿 / 审核结果）+ 一句提示「你可以说：确认继续 / 补充素材 / 改大纲…」。
+   用户下一句自然语言 → 意图解析 → `submitIntervention`。
+4. 问答：任意时刻用户提问 → 旁路回答，不打断写作状态。
+5. 素材不足：意图解析 `needResearch` 或后端 `section_help` → 对话追问「素材不足，帮你重搜？」
+   → 确认后重搜 → 自动续跑 pending 意图。
+
+### 5.4 问答旁路（新能力）
+
+「对写作内容提问」不应改写作 state。两种实现：
+
+- **轻量（推荐先做）**：意图解析节点直接带回 `answer`（后端能读 state，一次调用出答案）。
+- **完整**：新起一条**只读**问答线程（lead_agent，context 注入当前草稿/大纲作为背景），
+  类似 `WritingSetupChat` 的 `useThreadStream` 模式，但只读不回填。
+
+---
+
+## 6. 后端改造方案
+
+### 6.1 意图解析入口（二选一）
+
+- **方案 A1（推荐，独立 REST）**：`app/gateway/routers/ai_writing.py` 新增
+  `POST /api/ai-writing/sessions/{id}/intent`，入参 `{text}`，后端读该 session 的
+  checkpoint state（素材/大纲/草稿摘要）+ 用 `ai_writing` 配置模型解析，返回第 4.1 的契约。
+  - 好处：不改图拓扑；前端拿到结果后再决定调 `startWriting`/`submitIntervention`。
+- 方案 A2（图内节点）：在图里加 `conversation_router` 节点。改动大、状态耦合高，**不推荐**首期。
+
+### 6.2 意图解析 prompt
+
+新增 `agents/ai_writing/prompts/intent_router_prompts.py`（或复用/扩展 `intent_parser.py`）：
+- 输入：用户文本、`current_status`、素材摘要（keywords + 每条 title/source）、大纲纲要、
+  草稿字数/章节标题、审核意见列表。
+- 输出：严格 JSON（第 4.1 契约）。要求模型**只在证据充分时给高 confidence**，
+  否则给 `clarify`（防误触发是硬指标）。
+
+### 6.3 「带目标的重搜」协议扩展（可选增强）
+
+现有 `supplement_search` 用 `user_query` 追加检索。为支持「改稿意见 → 缺素材 → 重搜 → 自动续跑」，
+建议在 `material_confirm` 的 resume 里新增可选字段 `resume_intent`（重搜完成后要自动执行的原始意图）。
+- 前端也可**纯前端**实现（重搜完成事件回来后再自动提交缓存的 pending payload），**首期优先前端实现**，避免动后端协议。
+
+### 6.4 追加自定义审核意见（`add_review_opinion`）
+
+`editor`/`pause_review` 目前只接受「接受/强制定稿」。要支持「你再补一条审核意见」，
+需在 `review_confirm` resume 里接受 `extra_review_notes`，`editor` 或 `writer_draft`
+修订时并入。首期可先降级为 `user_revise` + notes（把用户的审核诉求当作改稿意见），
+**完整版**再扩协议。
+
+### 6.5 不需要改的部分
+
+- 四个阶段大脑节点（researcher/writer_outline/writer_draft/editor）逻辑不动。
+- 五个暂停点、checkpoint、StreamBridge、持久化不动。
+
+---
+
+## 7. 数据流时序（改稿 + 素材不足自动重搜）
+
+```
+用户: "第三段补个2024年的行业案例"
+  │
+  ▼ POST /api/ai-writing/sessions/{id}/intent  { text }
+后端: 读 state(素材摘要) + LLM 解析
+  │  返回 { intent:revise_draft, action:user_revise,
+  │         payload:{userRevisionNotes:...},
+  │         needResearch:true, researchQuery:"2024 行业案例" }
+  ▼
+前端: needResearch=true → 缓存 pending=payload
+  │  对话追问/直接执行: submitIntervention(material_confirm, supplement_search, user_query="2024 行业案例")
+  ▼ LangGraph resume → researcher 补素材 → materials_ready
+前端: 收到新素材 → 自动提交 pending
+  │  submitIntervention(draft_confirm, user_revise, userRevisionNotes=...)
+  ▼ writer_draft 用新素材改稿 → draft_chunk... → draft_ready → pause_draft
+前端: 消息流展示新草稿 + "已按你的意见改写并补充了案例"
+```
+
+---
+
+## 8. 关键实现细节与坑
+
+1. **暂停态识别**：对话层必须知道「现在停在哪个 pause_point」才能正确映射 action。
+   `AIWritingContext` 已有 `currentPause`/`status`，直接读。
+2. **防误触发**：低置信意图一律走 `clarify` 反问，绝不猜着执行（尤其 `finalize`/`re_search` 这种代价大的）。
+3. **pending 意图队列**：素材不足重搜是「先插一段、再回原意图」，需要一个小状态机记住 pending，
+   并处理「重搜后用户又改主意」的情况（重搜完成前允许覆盖 pending）。
+4. **回退/undo（H 类）**：依赖 checkpoint 回滚，`runtime/runs/worker.py` 有 `rollback` 概念，
+   首期可**不做**或只做「重跑当前阶段」。
+5. **问答旁路不污染 transcript**：问答消息可标记 `kind:'qa'`，与写作进度事件区分持久化。
+6. **流式产物→消息卡片**：复用现有 `OutlineStreamingView`/`DraftStreamingPreview` 等的**展示部分**，
+   套进消息气泡即可，不必重写渲染。
+7. **离线内网**：意图解析模型走 `config.yaml → ai_writing` 里的配置模型；检索仍走技能/内网 ES，
+   不联网（与现有并行席位「禁 web_search」的离线策略一致）。
+
+---
+
+## 9. 分阶段实施路线图
+
+**阶段 0 — 骨架（不含意图）**
+- 新路由 + 新页面 `AIWritingChatPage`，复用 `AIWritingContext`/`useStream`/`DraftPanel`。
+- 底部对话框先只做「空闲 `start_writing` + 暂停点固定按钮」跑通端到端（相当于把干预卡换成消息）。
+
+**阶段 1 — 意图解析（核心）**
+- 后端 `POST /sessions/{id}/intent` + intent prompt，返回第 4.1 契约。
+- 前端接入：自然语言 → 意图 → `startWriting`/`submitIntervention`，覆盖 A~F 类意图。
+- 加高频短句规则快路径 + 低置信 `clarify` 反问。
+
+**阶段 2 — 问答旁路 + 素材不足自动重搜**
+- G 类问答（先用 intent 节点直接带 `answer`）。
+- `needResearch` + pending 意图机制（前端实现重搜后自动续跑）。
+
+**阶段 3 — 增强协议（按需）**
+- `add_review_opinion` 扩 `review_confirm` 协议、`resume_intent` 后端化、undo/回退。
+
+**阶段 4 — 打磨**
+- 消息卡片视觉、历史回看（复用 transcript）、后台挂起入口、灰度到侧边栏。
+
+---
+
+## 10. 关键文件清单（落地时对照）
+
+### 新增（前端）
+- `open-canvas/pages/AIWritingChatPage.tsx` — 新页面
+- `open-canvas/components/ai-writing-chat/WritingChatComposer.tsx` — 统一输入框
+- `open-canvas/components/ai-writing-chat/WritingChatThread.tsx` — 消息流
+- `open-canvas/components/ai-writing-chat/progressToMessage.ts` — 事件→消息适配
+- `open-canvas/api/ai-writing-intent.ts` — 意图解析客户端
+- 路由注册：`open-canvas/OpenCanvasRoutes.tsx`（+ 可选 `sidebar-menu.ts`）
+
+### 新增（后端）
+- `app/gateway/routers/ai_writing.py` — 加 `POST /sessions/{id}/intent`
+- `agents/ai_writing/prompts/intent_router_prompts.py` — 意图 prompt
+- （阶段 3）`state.py` / `nodes/*` — 扩 `review_confirm`、`resume_intent`
+
+### 复用（尽量不改）
+- `open-canvas/contexts/AIWritingContext.tsx`、`hooks/useAIWritingStream.ts`
+- `open-canvas/components/ai-writing/AIWritingDraftPanel.tsx` 及各流式展示组件
+- `open-canvas/types/ai-writing.ts`（按需扩字段）
+- `agents/ai_writing/graph.py`、四个阶段节点、五个暂停点
+
+### 不动
+- 旧 `open-canvas/pages/AIWritingPage.tsx` 及 `AIWritingForm`/`WritingFormContext`/`InterventionCard`
+
+---
+
+## 11. 待确认
+
+1. 意图解析引擎是否采用**推荐的方案 A（后端 LLM 节点）**？
+2. 新页面是**独立入口**（侧边栏新增）还是先**内部灰度**（仅直链）？
+3. 「素材不足自动重搜」首期是否接受**前端实现 pending 续跑**（不动后端 resume 协议）？
+4. 问答旁路首期是否接受**意图节点直接带答案**（不新起只读线程）？
+
+> 以上默认按「A / 内部灰度 / 前端 pending / 意图节点带答案」推进，如需调整请指出。

frontend-web/docs/ai-writing-说明.md

@@ -1,787 +0,0 @@
-# AI 写作 — 故障排查与解决方案说明
-
-> **本文档目的**：完整记录 AI 写作子系统在内网 Docker 部署后出现的问题、根因、已落地的修复、剩余风险、以及未来的解决方案路径。
->
-> **适用读者**：维护 AI 写作功能的前端/后端开发者、内网部署运维。
->
-> **更新日期**：2026-05-20
-
----
-
-## 一、问题背景
-
-### 起因
-内网 Docker 部署后，AI 写作出现两类报错：
-
-| 接口 | 报错 | 频率 |
-|---|---|---|
-| `PUT /api/ai-writing/sessions/{id}/transcript` | HTTP 500 | 经常 |
-| `POST /api/ai-writing/{id}/resume` | HTTP 4xx（用户记忆为 400，实际可能是 404） | 经常，且没有 Docker 重启时也发生 |
-
-### 这两个接口的作用
-
-#### 1. `PUT /sessions/{id}/transcript` — 对话时间线持久化
-- **职责**：保存前端组装的完整对话时间线（progressEvents + completedInterventions）到 MySQL
-- **调用时机**：前端在写作过程中**反复 PUT**（事件累计、干预完成、草稿生成等节点全量覆盖）
-- **存到哪**：MySQL 的 `ai_writing_sessions.transcript` 列（LONGTEXT）
-- **用途**：用户**关闭页面后再回来 / 刷新 / 看历史会话**时，从 DB 拉回这段时间线，UI 上回显出「跟实时一样的对话历史」
-- **定位**：**纯锦上添花** — 失败了用户当下写作完全不受影响，只是历史回显会缺失/不完整
-
-#### 2. `POST /{id}/resume` — 写作流程的核心控制接口
-- **职责**：提交用户在干预点的决策，让 LangGraph 从挂起的 interrupt 点继续推进
-- **调用时机**：用户在 4 个 interrupt 点（素材确认 / 大纲确认 / 草稿确认 / 审核确认）做出决定后
-- **传什么**：用户的决策内容（确认的素材 id、修改后的大纲、用户的修订意见、章节求助决策…）
-- **定位**：**流程主干** — 它失败，用户就**真的卡死**在干预点
-
----
-
-## 二、根因分析
-
-### 根因 1：`transcript` 列容量不足 + 路由层无兜底
-- MySQL `TEXT` 列上限 64 KB
-- 用户写作过程中累计 `progressEvents`（含每个流式 chunk）+ `completedInterventions` 后，JSON blob 经常超过 64 KB
-- `session.commit()` 抛 `DataError: Data too long for column 'transcript'`
-- 原路由没有 try/except，异常直接冒泡成 HTTP 500
-
-### 根因 2：内存中的会话状态在多 worker 部署下隔离
-后端用了大量模块级 dict 维护会话状态：
-
-```python
-_event_queues:          dict[str, asyncio.Queue]  # SSE 事件队列
-_session_pending_pause: dict[str, tuple]          # 挂起的 await_user 事件
-_session_model_names:   dict[str, str]            # 用户选的模型
-_session_interventions: dict[str, list]           # 累计干预历史
-_session_repos:         dict[str, repo]           # DB 仓库引用
-_session_user_ids:      dict[str, str]            # 用户 id
-_session_article_types: dict[str, list]           # 文章类型列表
-```
-
-**uvicorn / gunicorn 多 worker 是多进程共享 socket**，OS 内核决定哪个 worker 接到请求，应用层和 nginx 都管不着。所以：
-
-```
-T0: POST /start → worker A 创建 _event_queues[sid] = QueueA
-                  graph 推进任务跑在 worker A
-T1: GET /stream → 落 worker B，没有 QueueA 的引用
-                  → 触发 _recover_session，从 sqlite 重建 QueueB
-                  → SSE 推 QueueB 但事件都在 QueueA 里
-T2: POST /resume → 落 worker C，同样无法看到 A/B 的状态
-```
-
-**结果**：SSE 时断时续、resume 偶发 404「会话状态已丢失」。
-
-### 根因 3：Graph 用了内存 checkpointer
-原代码：
-```python
-# ai_writing/graph.py
-checkpointer = MemorySaver()
-```
-进程内的 `MemorySaver` 重启即丢，**容器重启或单 worker 进程被回收**后所有进行中会话都拿不到。
-
-### 根因 4：路径配错
-`config.yaml` 里 sqlite 路径写成了 Windows 绝对路径 `D:\cursor-work\...`，Linux 容器里根本无法解析。
-
----
-
-## 三、已落地的修复（已合入 dhk-1 分支）
-
-### 修复 1：`transcript` 列改 LONGTEXT + 路由兜底
-
-| 文件 | 改动 |
-|---|---|
-| `packages/harness/deerflow/persistence/types.py` | 新增 `PortableLongText` 类型（MySQL→LONGTEXT，SQLite/PG→TEXT） |
-| `packages/harness/deerflow/persistence/ai_writing_sessions/model.py` | `transcript` 列改成 `PortableLongText` |
-| `packages/harness/deerflow/persistence/migrations/versions/20260519_02_ai_writing_transcript_longtext.py` | Alembic 迁移：MySQL 上 `ALTER ... type_=LONGTEXT()` |
-| `app/gateway/routers/ai_writing.py` | `save_transcript` 整段 try/except 包裹，**任何异常都返回 `{success: false, reason}`，永远不抛 5xx** |
-
-**结果**：transcript 500 永远不会再发生。前端已经做了 fire-and-forget 容错，失败只 `console.warn`，写作流程不阻断。
-
-### 修复 2：Checkpointer 改为持久化 SQLite
-
-| 文件 | 改动 |
-|---|---|
-| `packages/harness/deerflow/agents/ai_writing/graph.py` | `MemorySaver()` → 懒加载 `AsyncSqliteSaver` |
-| 同上 | 新增 `get_ai_writing_graph()` / `get_ai_writing_checkpointer()` / `shutdown_ai_writing_graph()` |
-| `offline-backend-20260512/config.yaml` | sqlite 路径改成相对路径 `.deer-flow/data/checkpoints.db` |
-
-**关键容错**：sqlite 初始化失败（磁盘满 / 权限 / aiosqlite 未装 / 损坏）会**自动降级 InMemorySaver**，写作流程能跑完，但跨重启不可恢复。
-
-### 修复 3：跨 worker / 进程重启会话恢复
-
-| 文件 | 改动 |
-|---|---|
-| `app/gateway/routers/ai_writing.py` | 新增 `_recover_session(session_id, request)` |
-
-当 worker 内存里没有该 session 时，从 sqlite checkpointer 读快照，重建 `_event_queues`、重新注入 `await_user` 事件。
-
-**效果**：worker B 收到的 resume 请求，能从 sqlite 找到 worker A 写下的 checkpoint，**resume 接口本身能跑通**（但 SSE 事件流仍隔离 — 见下文剩余风险）。
-
-### 修复 4：多层失败兜底，保证写作流程能继续
-
-| 改动 | 作用 |
-|---|---|
-| `_sse(event, data)` 加 `default=str` + notice 帧降级 | JSON 序列化失败不会让 SSE 断开 |
-| 所有 DB 写入（草稿/审核/干预/status）已包 try/except | DB 异常吞掉，graph 继续推 |
-| 文章类型加载失败 → 退回 `[]` | intent_parser 仍能跑 |
-| `/start` 加 503 兜底 | graph 构建失败时给前端可读错误而不是 500 |
-
-### 修复 5：定期清理 + admin 触发接口
-
-| 文件 | 改动 |
-|---|---|
-| `app/gateway/ai_writing_cleanup.py` | 新文件：cron 调度 + 联动清理（MySQL 行 + sqlite checkpointer thread） |
-| `packages/harness/deerflow/persistence/ai_writing_sessions/sql.py` | 新增 `list_older_than()` / `delete_by_ids()` |
-| `app/gateway/app.py` | lifespan 启动/停止清理任务 |
-| `app/gateway/routers/ai_writing.py` | 新增 `POST /api/ai-writing/admin/cleanup` 手动触发接口（admin only） |
-| `config.yaml` | 新增 `ai_writing.cleanup` 段（默认每天凌晨 3 点跑，保留 7 天） |
-
-**关键安全机制**：清理永远跳过 `_event_queues` 里仍在跑的会话（**活跃保护**），即使 admin 手动传 `retention_days: 0` 也不会秒杀正在写作的用户。
-
-### 修复 6：优雅关闭 — In-flight Drain
-
-| 文件 | 改动 |
-|---|---|
-| `app/gateway/routers/ai_writing.py` | 新增 `_inflight_graph_tasks` + `_spawn_graph_task()` + `wait_for_inflight_graph_tasks(timeout)` |
-| `app/gateway/app.py` | lifespan shutdown 顺序：取消清理 → **等 in-flight 写作 task 收尾（30s 超时）** → 关 checkpointer connection |
-
-容器收到 SIGTERM 时，给正在跑的写作 30 秒窗口跑到下一个 interrupt / END，已生成的 checkpoint 都安全落盘。
-
-### 修复 7：多 worker 配置陷阱检测
-
-| 文件 | 改动 |
-|---|---|
-| `app/gateway/app.py` | lifespan startup 检测 `WEB_CONCURRENCY > 1` 或 `/proc` 里同名 uvicorn 进程数 > 1 → 打 ERROR 日志 |
-
-下次启动容器看 docker logs 第一屏就能看到强提醒。
-
----
-
-## 四、当前状态评估
-
-### transcript 500
-✅ **彻底修复**，跟 worker 数无关。LONGTEXT 列 + 路由兜底双保险。
-
-### resume 报错
-⚠️ **大幅缓解**：
-- 接口本身（在 worker > 1 下）能跑通
-- sqlite 共享让 worker B 也能恢复 worker A 创建的 session
-
-❌ **未彻底解决**：
-- SSE 事件流仍 per-worker 隔离
-- 用户可能看到「进度时有时无、需要刷新页面才能看到草稿」
-- 但**草稿、审核结果**都落到 MySQL，刷新 `/sessions/{id}` 总能看到最终成品
-
-### 「写作流程能不能跑完」
-✅ **能**。最坏情况下：
-- 用户感受：进度断断续续，需要刷新几次
-- 数据保证：草稿和审核都落 MySQL，**写出来的内容不会丢**
-
----
-
-## 五、剩余风险
-
-### 风险 A：多 worker 下 SSE 事件流隔离 ⚠️ 最重要
-
-**症状**：用户 SSE 长连接绑在 worker B，但 graph 推进任务跑在 worker A，事件 put 进 A 的 queue → SSE 收不到。
-
-**为什么不能用 `--workers 1` 解决**：业务团队反馈其他业务功能需要多 worker。
-
-**解决方案见第六章**。
-
-### 风险 B：容器优雅关闭时 in-flight 写作进度
-
-**当前缓解**：30 秒 drain timeout 让 graph 跑到下一个 checkpoint。
-
-**完美方案**（如有需求）：无法 100% 防护，只能尽量缩短「未落 checkpoint」窗口。
-
-### 风险 C：节点级别 LLM 抽风
-
-某个写作节点调用 LLM 时网络抖动 / 限流 → astream 抛错 → session 结束。
-
-**当前缓解**：astream level 已 try/except，推 error 事件。用户从 checkpoint 重试。
-
-**改进方向**（不在本次修复范围）：
-- 给节点加 `tenacity.retry` 重试装饰器
-- 节点抛错时把已生成的部分塞进 progress_events
-
-### 风险 D：跨 worker 恢复时降级丢失
-
-worker B 从 sqlite 恢复 worker A 的 session 时，以下数据回退到默认：
-
-| 数据 | 默认值 | 影响 |
-|---|---|---|
-| `_session_model_names` | `""` | 退回默认模型 |
-| `_session_interventions` | `[]` | 本次 resume 之前的干预历史从内存里丢（MySQL 里有副本，但内存累计不全） |
-| `_session_article_types` | `[]` | 没影响（graph 早过了 intent_parser） |
-
-**改进方向**：恢复时从 MySQL 反向填充内存元数据（约 20 行代码）。
-
----
-
-## 六、Worker > 1 限制下的解决方案路径
-
-### 三条路径对比
-
-| 方案 | 是否引入新依赖 | 代码改动 | 运维改动 | 适用场景 |
-|---|---|---|---|---|
-| **B. Redis Pub/Sub 共享状态** | ⚠️ 需 Redis | ~150 行 | docker-compose 加 redis | 已有 Redis 或愿意上 |
-| **C. AI 写作独立单 worker 进程** | 无 | ~30 行 | docker-compose 加一个容器 / 进程 + nginx 转发 | 不想上 Redis |
-| **F. 多容器单 worker + nginx sticky** | 无 | ~5 行（nginx config） | 把 1 个多 worker 容器拆成 N 个单 worker 容器 | 已经在做容器编排 |
-
-### 方案 B：Redis Pub/Sub（最彻底）
-
-**改造点**：
-
-```
-之前（per-worker memory dict）            之后（Redis 共享）
-─────────────────────────                ─────────────────────
-_event_queues[sid] = asyncio.Queue()  →  Redis Pub/Sub channel "ai_writing:events:{sid}"
-_session_pending_pause                →  Redis Hash "ai_writing:pause"
-_session_model_names                  →  Redis Hash "ai_writing:meta:model"
-_session_interventions                →  Redis Hash + JSON
-_session_repos / _session_user_ids    →  Redis Hash
-```
-
-**关键设计**：
-1. `/start` 在 worker A：graph 推进任务跑在 A，事件 publish 到 Redis channel
-2. `/stream` 在 worker B：subscribe Redis channel，把消息转 SSE 推前端
-3. `/resume` 在 worker C：用 Redis 分布式锁保证「同一 session 同时只有一个 worker 驱动 graph」
-
-**优点**：根治。任何 worker 数、任何部署形态都能跑。
-
-**缺点**：
-- 引入 Redis 依赖（运维负担）
-- 代码改动较大（约 150 行）
-- 需要处理 Redis 断连 / 分布式锁释放等边缘情况
-
-### 方案 C：AI 写作独立服务（次推荐）
-
-**做法**：在同一个容器里多起一个 uvicorn 进程，专门处理 `/api/ai-writing/*`，**显式 `--workers 1`**。
-
-```bash
-# 主 gateway（多 worker，处理其他业务）
-uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001 --workers 4
-
-# AI 写作专用单 worker
-uvicorn app.gateway.app:app --host 0.0.0.0 --port 8002 --workers 1
-```
-
-nginx 配置：
-```nginx
-location /api/ai-writing/ {
-    proxy_pass http://localhost:8002;
-    proxy_buffering off;
-    proxy_read_timeout 3600s;
-}
-
-location / {
-    proxy_pass http://localhost:8001;
-}
-```
-
-**优点**：
-- 零代码改动
-- 不引入新依赖
-- AI 写作彻底单 worker，问题根除
-
-**缺点**：
-- 容器内多一个进程
-- 内存占用 +1 份 Python runtime（约 200 MB）
-
-### 方案 F：多容器单 worker + nginx sticky
-
-**做法**：把当前 1 个 4 worker 容器，拆成 4 个 1 worker 容器，nginx 用 `ip_hash` 做 sticky。
-
-```yaml
-# docker-compose.yml
-services:
-  gateway-1: { ports: ["8001:8001"], command: ["...", "--workers", "1"] }
-  gateway-2: { ports: ["8002:8001"], command: ["...", "--workers", "1"] }
-  gateway-3: { ports: ["8003:8001"], command: ["...", "--workers", "1"] }
-  gateway-4: { ports: ["8004:8001"], command: ["...", "--workers", "1"] }
-
-  nginx:
-    # upstream 配 ip_hash，让同一个客户端粘到同一个容器
-```
-
-```nginx
-upstream gateway_pool {
-    ip_hash;
-    server gateway-1:8001;
-    server gateway-2:8001;
-    server gateway-3:8001;
-    server gateway-4:8001;
-}
-```
-
-**优点**：零代码改动，标准做法
-
-**缺点**：
-- 改动 docker-compose
-- 客户端 IP 不均匀时负载不均衡（但 AI 写作低并发场景影响小）
-
-### 推荐顺序
-
-1. **方案 C（AI 写作独立单 worker 进程）** — 改动最小、风险最低、立刻可上
-2. **方案 F（多容器 sticky）** — 如果你们已经在做多容器编排
-3. **方案 B（Redis）** — 长期方案，等真正需要水平扩容时再上
-
----
-
-## 六-A、方案 C 在 Docker 容器内的详细实施指南
-
-> **目标**：在不引入新依赖、不动业务代码、不拆容器的前提下，让 AI 写作走专门的单 worker 进程，其它业务继续走多 worker。
->
-> **基础设施**：本项目镜像基于 `python:3.12-slim-bookworm`，用 `uv` 管理依赖，Dockerfile 位于 `offline-backend-20260512/backend/Dockerfile`，默认入口是
->
-> ```
-> CMD ["sh", "-c", "cd backend && PYTHONPATH=. uv run --no-sync uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001"]
-> ```
-
-### 总览：单容器双 uvicorn 进程
-
-```
-                       ┌─────────────── nginx (容器外或前置) ───────────────┐
-                       │                                                    │
-   /api/ai-writing/  ──┼──►  container:8002  (uvicorn --workers 1)   ───►  AI 写作专用
-   其余  /api/*      ──┼──►  container:8001  (uvicorn --workers N)   ───►  其他业务
-                       └────────────────────────────────────────────────────┘
-                                          ▲
-                                          │  (两个进程跑在同一个容器里，共享 .deer-flow 卷
-                                          │   ／同一个 MySQL ／同一个 sqlite checkpoints.db)
-```
-
-两进程都用 **同一个 `app.gateway.app:app`**，区别只在：
-- `8002` 单 worker，专门接 `/api/ai-writing/*`
-- `8001` 多 worker，接其他所有路由
-- 容器内用 `supervisord` 同时托管这两个 uvicorn
-
-### 步骤 1：在镜像里加 supervisord
-
-编辑 `offline-backend-20260512/backend/Dockerfile`，给 **runtime stage**（第 67 行 `FROM python:3.12-slim-bookworm` 之后）补一段：
-
-```dockerfile
-# 安装 supervisord（约 4 MB，纯 Python，无需编译）
-RUN apt-get update \
-    && apt-get install -y --no-install-recommends supervisor \
-    && rm -rf /var/lib/apt/lists/*
-```
-
-如果内网无法访问 debian 源，可用现有的 `APT_MIRROR` build-arg：
-
-```bash
-docker build \
-  --build-arg APT_MIRROR=mirrors.aliyun.com \
-  -f offline-backend-20260512/backend/Dockerfile \
-  -t deerflow-gateway:dual .
-```
-
-### 步骤 2：写 supervisord 配置
-
-新建 `offline-backend-20260512/backend/deploy/supervisord.conf`：
-
-```ini
-[supervisord]
-nodaemon=true               ; 容器主进程，必须前台
-user=root
-logfile=/dev/null           ; 让子进程日志直接走 stdout/stderr，由 docker logs 接管
-logfile_maxbytes=0
-pidfile=/tmp/supervisord.pid
-
-; ─── 主 Gateway：多 worker，处理除 ai-writing 以外的所有业务 ───
-[program:gateway-main]
-command=uv run --no-sync uvicorn app.gateway.app:app
-        --host 0.0.0.0 --port 8001
-        --workers %(ENV_GATEWAY_MAIN_WORKERS)s
-        --proxy-headers --forwarded-allow-ips=*
-directory=/app/backend
-environment=PYTHONPATH=".",AI_WRITING_DEDICATED_PORT="8002"
-autostart=true
-autorestart=true
-stopasgroup=true
-killasgroup=true
-stopsignal=TERM
-stopwaitsecs=35              ; 给 lifespan 的 30s drain 留点余量
-stdout_logfile=/dev/stdout
-stdout_logfile_maxbytes=0
-stderr_logfile=/dev/stderr
-stderr_logfile_maxbytes=0
-
-; ─── AI 写作专用：单 worker，处理 /api/ai-writing/* ───
-[program:gateway-aiwriting]
-command=uv run --no-sync uvicorn app.gateway.app:app
-        --host 0.0.0.0 --port 8002
-        --workers 1
-        --proxy-headers --forwarded-allow-ips=*
-directory=/app/backend
-environment=PYTHONPATH=".",DEER_FLOW_ROLE="ai-writing"
-autostart=true
-autorestart=true
-stopasgroup=true
-killasgroup=true
-stopsignal=TERM
-stopwaitsecs=35
-stdout_logfile=/dev/stdout
-stdout_logfile_maxbytes=0
-stderr_logfile=/dev/stderr
-stderr_logfile_maxbytes=0
-```
-
-**几个关键点**：
-- `nodaemon=true` 让 supervisord 自己变成 PID 1，docker stop 发的 SIGTERM 才能正确传给它，它再传给两个 uvicorn 子进程
-- `stopasgroup=true` + `killasgroup=true` 确保 uvicorn 多 worker 模式下所有子进程一起退
-- `stopwaitsecs=35` 必须大于 lifespan 的 30s drain 超时，否则 in-flight 写作会被 SIGKILL
-- `%(ENV_GATEWAY_MAIN_WORKERS)s` 让主进程 worker 数走环境变量，下面会传
-
-把这个配置文件 COPY 进镜像（在 Dockerfile runtime stage `COPY --from=builder /app/backend ./backend` 之后加）：
-
-```dockerfile
-COPY backend/deploy/supervisord.conf /etc/supervisor/conf.d/deerflow.conf
-```
-
-### 步骤 3：把 Dockerfile 入口换成 supervisord
-
-把 Dockerfile **runtime stage 最后一行** 改成：
-
-```dockerfile
-# 之前
-CMD ["sh", "-c", "cd backend && PYTHONPATH=. uv run --no-sync uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001"]
-
-# 之后
-EXPOSE 8001 8002 2024
-CMD ["supervisord", "-c", "/etc/supervisor/conf.d/deerflow.conf"]
-```
-
-> **`dev` stage 不用改**：开发环境本来就是单 worker、reload 模式，方案 C 是为生产准备的，dev stage 维持原 CMD。
-
-### 步骤 4：暴露端口 / 挂卷 / 环境变量
-
-启动容器时：
-
-```bash
-docker run -d --name deerflow-gateway \
-  -p 8001:8001 \
-  -p 8002:8002 \
-  -e GATEWAY_MAIN_WORKERS=4 \
-  -e DEER_FLOW_CONFIG_PATH=/app/config.yaml \
-  -v /your/host/path/.deer-flow:/app/.deer-flow \
-  -v /your/host/path/config.yaml:/app/config.yaml:ro \
-  -v /your/host/path/extensions_config.json:/app/extensions_config.json:ro \
-  deerflow-gateway:dual
-```
-
-**两个进程必须共享 `.deer-flow` 卷** —— 因为 `checkpoints.db` 在里面（`offline-backend-20260512/config.yaml` 里配的是相对路径 `.deer-flow/data/checkpoints.db`）。两个进程跑在同一个容器内，天然共享文件系统，**这一步不用做任何额外配置**，只要确认数据卷挂出去就行。
-
-> ⚠️ 即便 8002 是单 worker，仍然推荐把 checkpointer 持久化到磁盘，因为：① 容器重启会重建进程；② 如果哪天临时改回多容器/多 worker，数据不丢；③ 跟主 gateway 共享 checkpoint，未来想做读副本也方便。
-
-### 步骤 5：nginx 路由
-
-如果你前面已经有 nginx（容器外或者另一个容器），把 AI 写作的路由独立出来：
-
-```nginx
-upstream gateway_main      { server gateway-host:8001; }
-upstream gateway_aiwriting { server gateway-host:8002; }
-
-server {
-    listen 80;
-    server_name deerflow.example.com;
-
-    # SSE 长连接必须关 buffering
-    proxy_buffering off;
-    proxy_request_buffering off;
-    proxy_http_version 1.1;
-    proxy_set_header Connection "";
-
-    # AI 写作 → 单 worker 后端
-    location /api/ai-writing/ {
-        proxy_pass http://gateway_aiwriting;
-        proxy_read_timeout 3600s;        # graph 跑得久，给足时间
-        proxy_send_timeout 3600s;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-
-    # 其它一切 API → 多 worker 后端
-    location /api/ {
-        proxy_pass http://gateway_main;
-        proxy_set_header Host $host;
-        proxy_set_header X-Real-IP $remote_addr;
-        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-        proxy_set_header X-Forwarded-Proto $scheme;
-    }
-
-    # 前端静态资源不变
-    location / {
-        proxy_pass http://frontend:5174;
-    }
-}
-```
-
-**`proxy_buffering off` 是必须的** —— 不关 buffering，nginx 会把 SSE 流缓冲到响应结束才一次性吐给前端，等于把流式写作变成「等几分钟啥都看不到 → 一下吐一整篇」。
-
-如果前端是 Vite 直连后端（开发态没走 nginx），就只需要把 `frontend-web` 里 AI 写作相关的 `fetch`/`EventSource` 改成 `:8002`，但更推荐 **始终走 nginx**，对前端透明。
-
-### 步骤 6：如果你用 docker-compose
-
-完整 compose 示例：
-
-```yaml
-services:
-  gateway:
-    image: deerflow-gateway:dual
-    container_name: deerflow-gateway
-    restart: unless-stopped
-    environment:
-      GATEWAY_MAIN_WORKERS: "4"
-      DEER_FLOW_CONFIG_PATH: /app/config.yaml
-    ports:
-      - "8001:8001"
-      - "8002:8002"   # 如果有外层 nginx，且 nginx 跟 gateway 同网段，可去掉这行只走内网
-    volumes:
-      - ./data/deer-flow:/app/.deer-flow
-      - ./config.yaml:/app/config.yaml:ro
-      - ./extensions_config.json:/app/extensions_config.json:ro
-    healthcheck:
-      test: ["CMD", "sh", "-c", "curl -fsS http://localhost:8001/health && curl -fsS http://localhost:8002/health"]
-      interval: 30s
-      timeout: 5s
-      retries: 3
-      start_period: 30s
-    stop_grace_period: 45s   # 给 supervisord 的 35s + 余量，让两路 drain 跑完
-
-  nginx:
-    image: nginx:1.27-alpine
-    depends_on: [gateway]
-    ports: ["80:80"]
-    volumes:
-      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
-```
-
-`stop_grace_period: 45s` 这一行很关键 —— docker-compose 默认只给 10s，到点直接 SIGKILL，in-flight 写作会全部丢。设到 45s 等于 supervisord 的 35s + 10s 余量。
-
-### 步骤 7：验证（按这个清单逐项过）
-
-```bash
-# 1) 两个进程都起来了
-docker exec deerflow-gateway sh -c 'ps -ef | grep -E "uvicorn|supervisord" | grep -v grep'
-# 期望看到：
-#   1 root   supervisord -c /etc/supervisor/conf.d/deerflow.conf
-#   N root   uvicorn app.gateway.app:app --port 8001 --workers 4
-#   M root   uvicorn app.gateway.app:app --port 8002 --workers 1
-#   (8001 那一行会有 N 个 worker 子进程，8002 那一行只有 1 个)
-
-# 2) 8002 只有 1 个 worker（这是方案 C 的命脉）
-docker exec deerflow-gateway sh -c 'pgrep -f "port 8002" | wc -l'
-# 期望 = 2（1 个 master + 1 个 worker）；如果 > 2，单 worker 没生效
-
-# 3) 8001 不再警告多 worker
-docker logs deerflow-gateway 2>&1 | grep -i 'WEB_CONCURRENCY'
-# 期望：没有 ERROR 警告（因为 8001 走的是其他业务，8002 走的是单 worker）
-
-# 4) 8002 进程能看到 ai_writing 持久化日志
-docker logs deerflow-gateway 2>&1 | grep 'AsyncSqliteSaver'
-# 期望至少 1 行：ai_writing: 使用 AsyncSqliteSaver (...)
-
-# 5) /api/ai-writing/* 走 8002，其他走 8001
-curl -sI http://deerflow.example.com/api/ai-writing/health   # 看 nginx access log 落到 gateway_aiwriting
-curl -sI http://deerflow.example.com/api/models              # 看落到 gateway_main
-
-# 6) 真跑一次 AI 写作，确认全程没有「resume 404 / 进度断流」
-```
-
-### 步骤 8：监控两个进程的健康
-
-supervisord 自带 `unix_http_server` + `supervisorctl`，但对容器化场景更直接的是看 docker logs：
-
-```bash
-# 实时看两个进程的日志
-docker logs -f deerflow-gateway 2>&1 | grep -E '(gateway-main|gateway-aiwriting)'
-
-# 进程级状态
-docker exec deerflow-gateway supervisorctl -c /etc/supervisor/conf.d/deerflow.conf status
-# 期望：
-#   gateway-main         RUNNING   pid 7,  uptime 0:05:12
-#   gateway-aiwriting    RUNNING   pid 18, uptime 0:05:12
-
-# 单独重启 AI 写作进程（不影响主业务，前端只是 AI 写作页几秒不可用）
-docker exec deerflow-gateway supervisorctl -c /etc/supervisor/conf.d/deerflow.conf restart gateway-aiwriting
-```
-
-### 资源开销（实测预估）
-
-| 项 | 单 worker 镜像 | 双进程镜像 | 增量 |
-|---|---|---|---|
-| 镜像大小 | 基线 | +约 5 MB | supervisord 依赖 |
-| 启动时 RSS | ~250 MB | ~450 MB | 多一份 Python runtime + 模型客户端预加载 |
-| 稳态 RSS | 视业务而定 | +约 200 MB | 第二个 worker 的常驻内存 |
-| CPU | 不变 | 不变 | 单 worker 进程空闲基本不占 CPU |
-
-**结论**：内存额外占用约 200 MB，对 4 GB 以上的部署机基本无压力。
-
-### 常见坑位
-
-1. **`stop_grace_period` 没改大 → 重启时 in-flight 写作被秒杀**
-   表现：每次 `docker compose restart` 都有用户报告「写到一半没了」。修复见步骤 6。
-
-2. **8002 没暴露 / nginx 没改 → 所有请求还是落 8001**
-   表现：症状跟没做方案 C 一样。验证步骤 5 的 curl 即可发现。
-
-3. **两路用了不同的 `config.yaml`**
-   表现：8001 跟 8002 行为不一致。务必让两个进程**只读同一个文件**（在 compose 里只挂一次卷）。
-
-4. **`.deer-flow` 卷没挂 → 8002 重启后会话全丢**
-   表现：用户刷新页面，AI 写作历史空白。修复：步骤 4 的 `-v` 必须有。
-
-5. **AI 写作进程崩溃后 supervisord 反复重启 → 日志爆炸**
-   表现：`gateway-aiwriting` 状态在 RUNNING/EXITED/BACKOFF 间反复。
-   修复：先 `supervisorctl tail gateway-aiwriting stderr` 看真正原因（多半是 sqlite 权限或配置文件路径），再修，**别盲目调 `autorestart=false`**。
-
-6. **想做 K8s 部署但还想用方案 C**
-   不要把两个进程塞一个 Pod，应该直接拆成两个 Deployment、共享 PVC（checkpoints.db）。这种情况下方案 C 已经变形成方案 F 的子集，建议直接走方案 F。
-
-### 回滚方案
-
-如果上线后发现问题，回滚只需要 1 步：
-
-```bash
-# 把 Dockerfile 最后一行换回原来的 CMD，重新 build + 重启
-CMD ["sh", "-c", "cd backend && PYTHONPATH=. uv run --no-sync uvicorn app.gateway.app:app --host 0.0.0.0 --port 8001"]
-```
-
-数据完全兼容（checkpoints.db、MySQL 表结构都跟单进程模式一致），**不会丢任何用户数据**，只是回到「resume 偶发 404、SSE 断断续续」的旧体验。
-
----
-
-## 七、运维操作清单
-
-### 部署前验证
-
-```bash
-# 1) 确认 .deer-flow 数据卷挂出来了（持久化的命脉）
-docker exec <gateway> ls -la /app/.deer-flow/data/
-# 应该能看到 checkpoints.db 文件（首次启动后会自动创建）
-
-# 2) 确认 alembic 迁移跑完了
-docker exec <gateway> sh -c "cd /app/backend && PYTHONPATH=. uv run alembic current"
-# 应该看到包含 20260519_02 的 head
-
-# 3) 确认 transcript 列已扩容
-docker exec <mysql> mysql -uroot -p<pwd> deerflow -e \
-  "SHOW COLUMNS FROM ai_writing_sessions LIKE 'transcript';"
-# Type 列应该是 longtext
-
-# 4) 查 worker 数
-docker exec <gateway> ps -ef | grep -E 'uvicorn|gunicorn'
-# 如果 > 1，且没做任何方案 C/F/B，启动日志会打 ERROR 警告
-```
-
-### 启动时关注的日志
-
-```bash
-docker logs <gateway> 2>&1 | head -100 | grep -iE 'ai_writing|checkpointer|worker'
-```
-
-期望看到：
-- `ai_writing: 使用 AsyncSqliteSaver (xxx.db)` — 持久化生效
-- `ai_writing_cleanup: 已启动 cron=...` — 清理任务起来了
-
-警告：
-- `⚠ 检测到 WEB_CONCURRENCY=N` — 多 worker 配置警告
-- `ai_writing: 持久化 checkpointer 不可用，退回 InMemorySaver` — sqlite 初始化失败，需立刻排查
-
-### 用户报告「会话丢失」时的排查
-
-```bash
-# 1) 查 sqlite 里这个 session 的快照
-docker exec <gateway> sh -c "sqlite3 /app/.deer-flow/data/checkpoints.db \
-  \"SELECT thread_id, checkpoint_ns FROM checkpoints WHERE thread_id='<session_id>' LIMIT 5;\""
-
-# 2) 查 MySQL 里这条会话
-docker exec <mysql> mysql -uroot -p<pwd> deerflow -e \
-  "SELECT id, status, draft_title, updated_at FROM ai_writing_sessions WHERE id='<session_id>';"
-
-# 3) 看 gateway 日志里这个 session 的活动轨迹
-docker logs <gateway> 2>&1 | grep '<session_id>' | tail -50
-
-# 4) 看是否有 recover_session 调用
-docker logs <gateway> 2>&1 | grep 'ai_writing: recovered' | tail -20
-
-# 5) 看是否有节点异常
-docker logs <gateway> 2>&1 | grep -E 'ai_writing graph segment failed|ai_writing.*error' | tail -20
-```
-
-### 手动触发清理（admin only）
-
-```bash
-# 用 admin 账号登录后，取 cookie，调清理接口
-curl -X POST 'http://<gateway>/api/ai-writing/admin/cleanup' \
-  -H 'Content-Type: application/json' \
-  -H 'Cookie: <admin session cookie>' \
-  -d '{"retention_days": 7}'
-```
-
-返回：
-```json
-{
-  "deleted_db": 12,
-  "deleted_checkpoints": 12,
-  "skipped_active": 1,
-  "elapsed_seconds": 0.234,
-  "params": { "retention_days": 7, "only_finished": false, "batch_size": 500 }
-}
-```
-
-`skipped_active` > 0 表示有正在跑的会话被活跃保护拦下来，不会被误删。
-
----
-
-## 八、相关文件索引
-
-### 后端
-- `offline-backend-20260512/backend/app/gateway/routers/ai_writing.py` — 路由 + 内存状态字典 + drain
-- `offline-backend-20260512/backend/app/gateway/ai_writing_cleanup.py` — 定期清理
-- `offline-backend-20260512/backend/app/gateway/app.py` — lifespan / 多 worker 检测
-- `offline-backend-20260512/backend/packages/harness/deerflow/agents/ai_writing/graph.py` — Graph 定义 + 持久化 checkpointer
-- `offline-backend-20260512/backend/packages/harness/deerflow/persistence/ai_writing_sessions/` — MySQL repo
-- `offline-backend-20260512/backend/packages/harness/deerflow/persistence/types.py` — `PortableLongText`
-- `offline-backend-20260512/backend/packages/harness/deerflow/persistence/migrations/versions/20260519_02_*.py` — LONGTEXT 迁移
-- `offline-backend-20260512/config.yaml` — `checkpointer:` + `ai_writing.cleanup:` 配置
-
-### 前端
-- `frontend-web/src/open-canvas/pages/AIWritingPage.tsx` — 页面顶部有快速排查注释
-- `frontend-web/src/open-canvas/api/ai-writing-sessions.ts` — transcript 保存（已做 fire-and-forget 容错）
-- `frontend-web/src/open-canvas/api/ai-writing.ts` — resume / stream
-
-### 测试
-- `tests/test_ai_writing_cleanup.py` — 清理 + drain + checkpointer 降级 + SSE 序列化（21 个测试）
-- `tests/test_ai_writing_session_recovery.py` — 跨 worker 会话恢复（8 个测试）
-- `tests/test_ai_writing_session_repo.py` — Repo（7 个测试）
-- `tests/test_ai_writing_transcript_endpoint.py` — transcript 兜底（5 个测试）
-- `tests/test_portable_long_text.py` — LONGTEXT 列类型（5 个测试）
-
-总测试：**51 个，全过**。
-
----
-
-## 九、变更历史
-
-| 日期 | Commit | 内容 |
-|---|---|---|
-| 2026-05-19 | c3d0c82 | 报错兜底（transcript LONGTEXT 迁移 + 路由 try/except + session 恢复） |
-| 2026-05-20 | （本次） | checkpointer 持久化 + 定期清理 + admin 接口 + 多层兜底 + drain + 多 worker 检测 |
-
----
-
-## 十、决策摘要（给未来的你/同事）
-
-> **如果你现在第一次接手这个问题**，按这个清单往下走：
->
-> 1. ✅ **transcript 500 不用管** — 已彻底修复
-> 2. ⚠️ **resume 报错的根因是多 worker** — sqlite 持久化已减轻，但 SSE 事件流仍隔离
-> 3. ⚠️ **写作能跑完，但用户体验断断续续** — 草稿数据安全，刷新就能看到
-> 4. 🎯 **要彻底解决，从方案 C / F / B 选一个**（建议从 C 开始）
-> 5. 🚨 **务必确认 `.deer-flow` 数据卷挂出来了** — 否则 sqlite 持久化白做
-> 6. 📊 **关注的日志关键字**：`ai_writing:`、`checkpointer`、`AsyncSqliteSaver`、`WEB_CONCURRENCY`
-
-如有疑问，先看本文件的「七、运维操作清单」做基础排查，再问当前维护者。

frontend-web/docs/embed-iframe-chat.md

@@ -0,0 +1,436 @@
+# 工作台问答 · iframe 嵌入开发说明
+
+本文档说明如何将 DeerFlow **通用工作台问答**（与 `/page/workspace/chats/*` 同一套 LangGraph 流式能力）以**普通 iframe** 形式嵌入第三方页面，并在**父页面无法读取子 frame 内 `thread_id`** 的前提下，轮询「本次问答是否已结束」。
+
+后端公开 API 实现见：`offline-backend-20260512/backend/app/gateway/routers/public_embed.py`  
+数据表：`embed_sessions`（迁移 `20260602_01`）
+
+---
+
+## 0. 速读
+
+| 角色 | 要做的事 |
+|------|----------|
+| **父页面** | 自己生成 `sessionId`（UUID），拼进 iframe `src`；用 `sessionId` 调公开 API 轮询 `finished` |
+| **iframe（DeerFlow）** | 打开 `/embed/chats/...`，自动登录、自动发问、登记 `sessionId → thread_id` |
+| **不需要** | 无界（wujie）、父页面拿 `thread_id`、DeerFlow 登录态 Cookie |
+
+**完成条件**：`GET .../sessions/{sessionId}/status` 返回 `finished === true`（且无进行中的 run，非澄清中断）。
+
+---
+
+## 1. 背景与约束
+
+### 1.1 业务目标
+
+- 第三方系统用 **iframe** 嵌 DeerFlow 问答 UI。
+- 传入：**问题文案**、**用户名**（走现有 `login/username`）、**主题色**。
+- 展示：**消息列表** + **沙箱/产物侧栏**（与主聊天相同的 `ChatBox`）；**隐藏**页面左侧栏、Workspace 侧栏、底部输入框。
+- 进入后 **自动发送** 首条用户消息并走流式问答。
+
+### 1.2 为何需要 `sessionId`
+
+iframe 与父页面通常 **跨域**，父页面 **不能** 读取子应用 URL 里的 `thread_id`（hash 路由在子 frame 内）。  
+因此约定：
+
+1. **父页面**在打开 iframe 前生成全局唯一的 `sessionId`；
+2. **子页面**在创建/确定 `thread_id` 后，调用后端 **登记接口** 写入 `session_id → thread_id`；
+3. **父页面**只凭 `sessionId` 查询状态，必要时响应里会带上 `thread_id`（可选使用）。
+
+---
+
+## 2. 端到端流程
+
+```mermaid
+sequenceDiagram
+  participant Parent as 父页面
+  participant Iframe as DeerFlow iframe
+  participant API as Gateway /api/public/embed
+
+  Parent->>Parent: sessionId = crypto.randomUUID()
+  Parent->>Iframe: iframe src 含 sessionId、message、username、theme
+  Iframe->>Iframe: loginByUsername + 自动 sendMessage
+  Iframe->>API: POST /sessions { session_id, thread_id }
+  loop 每 1–3s
+    Parent->>API: GET /sessions/{sessionId}/status
+    API-->>Parent: registered, finished, thread_id
+  end
+```
+
+---
+
+## 3. 前端路由与页面
+
+### 3.1 路由（独立于 `/page/*`）
+
+在 `App.tsx` 注册，**不经过** `PageRoutes` / `PageSidebar`，因此无外层导航与 Workspace 侧栏。
+
+| 路由 | 组件 | 说明 |
+|------|------|------|
+| `/embed/chats/:thread_id` | `EmbedChatPage`（外包 `ChatRuntime`） | `thread_id` 可为 `new` 或已有 UUID |
+
+示例（HashRouter，注意 `#`）：
+
+```
+http://localhost:5173/#/embed/chats/new?sessionId=...&message=...&username=guest&theme=red
+```
+
+开发环境端口以本地 Vite 为准（如 5173 / 5174）。
+
+### 3.2 URL 查询参数
+
+| 参数 | 必填 | 说明 |
+|------|------|------|
+| `sessionId` 或 `session_id` | **是** | 父页面生成的关联 id，8–128 位，仅字母数字 `_` `-` |
+| `message` / `question` / `text` | 建议 | 首条用户问题；有则进入后自动发送 |
+| `username` / `userName` | 否 | 默认 `guest`，对应 `POST /api/v1/auth/login/username` |
+| `theme` | 否 | `dark-blue` → 深色；`red` 等 → 浅色（与 `LoginPage` 一致） |
+
+缺少 `sessionId` 时，嵌入页会提示错误，不会发起登记。
+
+### 3.3 相关源码
+
+| 路径 | 职责 |
+|------|------|
+| [src/pages/EmbedChatPage.tsx](../src/pages/EmbedChatPage.tsx) | 嵌入页：登录、自动发问、登记 session、仅消息列表 + ChatBox |
+| [src/core/embed/params.ts](../src/core/embed/params.ts) | 从 URL 解析嵌入参数 |
+| [src/core/embed/status-api.ts](../src/core/embed/status-api.ts) | 登记 / 轮询 API 封装 |
+| [src/App.tsx](../src/App.tsx) | 路由注册 |
+
+### 3.4 UI 行为说明
+
+- **隐藏**：`PageSidebar`、`WorkspaceSidebar`、`InputBox`、顶栏标题栏等（相对完整 `ChatPage`）。
+- **保留**：`MessageList`、流式指示、澄清卡片（若 agent 触发 `ask_clarification`）、右侧 **产物/沙箱**（`ChatBox` 内 60/40 分栏逻辑与主聊天一致）。
+- **线程 id**：新建会话时客户端先分配 UUID，`onStart` 后 `history.replaceState` 更新 hash 为 `/embed/chats/{真实id}`（与主聊天 `ChatPage` 相同手法，避免整页重载）。
+
+---
+
+## 4. 公开 HTTP API（无需鉴权）
+
+前缀：`/api/public/embed/`（走 Gateway，与 `VITE_BACKEND_BASE_URL` 一致，默认 `http://47.88.25.99:7001/`）。
+
+CSRF / Auth 中间件对 `/api/public/` 放行；请求 **不需要** Cookie。
+
+### 4.1 登记映射（iframe 内自动调用）
+
+```http
+POST /api/public/embed/sessions
+Content-Type: application/json
+
+{
+  "session_id": "parent-generated-uuid",
+  "thread_id": "e9c7d09e-821d-421f-ae24-e5ddfe0cff5b"
+}
+```
+
+**响应：**
+
+```json
+{
+  "session_id": "parent-generated-uuid",
+  "thread_id": "e9c7d09e-821d-421f-ae24-e5ddfe0cff5b",
+  "registered": true
+}
+```
+
+同一 `session_id` 再次 POST 会 **更新** `thread_id`（例如 `onStart` 后 id 变化）。
+
+### 4.2 轮询状态（父页面使用）
+
+```http
+GET /api/public/embed/sessions/{session_id}/status
+```
+
+**尚未登记**（iframe 仍在加载或未 POST）：
+
+```json
+{
+  "session_id": "parent-generated-uuid",
+  "registered": false,
+  "thread_id": null,
+  "finished": false,
+  "thread_status": "pending",
+  "has_active_run": false,
+  "latest_run_status": null
+}
+```
+
+**已登记且问答进行中：**
+
+```json
+{
+  "session_id": "parent-generated-uuid",
+  "registered": true,
+  "thread_id": "e9c7d09e-821d-421f-ae24-e5ddfe0cff5b",
+  "finished": false,
+  "thread_status": "idle",
+  "has_active_run": true,
+  "latest_run_status": "running"
+}
+```
+
+**已登记且已结束：**
+
+```json
+{
+  "session_id": "parent-generated-uuid",
+  "registered": true,
+  "thread_id": "e9c7d09e-821d-421f-ae24-e5ddfe0cff5b",
+  "finished": true,
+  "thread_status": "idle",
+  "has_active_run": false,
+  "latest_run_status": "success"
+}
+```
+
+#### 字段说明
+
+| 字段 | 含义 |
+|------|------|
+| `registered` | 是否已收到 iframe 的 POST 登记 |
+| `finished` | **父页面应以此为准**：无 inflight run，且线程非 running/busy，且非 `interrupted`（澄清等待用户） |
+| `thread_status` | 从 checkpoint 推导：`idle` / `interrupted` / `error` 等 |
+| `has_active_run` | 是否存在 pending/running 的 LangGraph run |
+| `latest_run_status` | 该线程最近一次 run 的状态：`success` / `error` / … |
+| `thread_id` | 解析出的 DeerFlow 线程 id（父页面可选用，非必须） |
+
+### 4.3 获取生成结果（父页面使用）
+
+问答结束后（建议先确认 `finished === true`），拉取本次模型输出：
+
+```http
+GET /api/public/embed/sessions/{session_id}/result
+```
+
+**尚未登记：**
+
+```json
+{
+  "session_id": "parent-generated-uuid",
+  "registered": false,
+  "thread_id": null,
+  "finished": false,
+  "thread_status": "pending",
+  "has_active_run": false,
+  "latest_run_status": null,
+  "messages": [],
+  "generated_text": "",
+  "generated_files": []
+}
+```
+
+**已登记且已有内容：**
+
+```json
+{
+  "session_id": "parent-generated-uuid",
+  "registered": true,
+  "thread_id": "e9c7d09e-821d-421f-ae24-e5ddfe0cff5b",
+  "finished": true,
+  "thread_status": "idle",
+  "has_active_run": false,
+  "latest_run_status": "success",
+  "messages": [
+    { "type": "human", "content": "请总结要点", "id": "..." },
+    { "type": "ai", "content": "根据分析，要点如下：...", "id": "..." }
+  ],
+  "generated_text": "根据分析，要点如下：...",
+  "generated_files": [
+    "/mnt/user-data/outputs/summary.md",
+    "/mnt/user-data/outputs/chart.png"
+  ]
+}
+```
+
+#### 结果字段说明
+
+| 字段 | 含义 |
+|------|------|
+| `messages` | 完整消息列表（与 checkpoint 中序列化结构一致，含 human / ai / tool 等） |
+| `generated_text` | 所有 `ai` / `assistant` 消息正文按顺序拼接（段落间空一行） |
+| `generated_files` | 本次会话产物的虚拟路径列表（与 UI 产物栏 `artifacts` 一致） |
+
+未结束时也可调用，会返回当前已有内容；`finished` 仍为 false 表示可能还会继续生成。
+
+### 4.4 按 thread_id 查询（可选）
+
+调试或父页面已持有 thread_id 时：
+
+```http
+GET /api/public/embed/threads/{thread_id}/status
+GET /api/public/embed/threads/{thread_id}/result
+```
+
+状态接口响应不含 `messages` / `generated_text` / `generated_files`；结果接口字段与 §4.3 相同（无 `session_id` / `registered`）。
+
+### 4.5 前端封装
+
+```ts
+import {
+  getEmbedSessionResult,
+  getEmbedSessionStatus,
+  registerEmbedSession,
+} from "@/core/embed/status-api";
+
+// 父页面（或你们自己的脚本）
+const status = await getEmbedSessionStatus(sessionId);
+if (status.registered && status.finished) {
+  const result = await getEmbedSessionResult(sessionId);
+  console.log(result.generated_text, result.generated_files);
+}
+
+// 仅 iframe 内需要
+await registerEmbedSession(sessionId, threadId);
+```
+
+`fetch` 使用 `credentials: "omit"`，不携带 DeerFlow 会话。
+
+---
+
+## 5. 父页面集成示例
+
+### 5.1 拼接 iframe
+
+```html
+<iframe
+  id="deerflow-embed"
+  title="DeerFlow 问答"
+  style="width:100%;height:600px;border:0"
+></iframe>
+```
+
+```javascript
+const sessionId = crypto.randomUUID();
+const base = "http://localhost:5173"; // 换成你们部署的前端 origin
+const params = new URLSearchParams({
+  sessionId,
+  message: "请根据附件总结要点",
+  username: "guest",
+  theme: "red",
+});
+document.getElementById("deerflow-embed").src =
+  `${base}/#/embed/chats/new?${params.toString()}`;
+```
+
+### 5.2 轮询直到结束
+
+```javascript
+const API = "http://47.88.25.99:7001/"; // VITE_BACKEND_BASE_URL
+
+async function pollUntilFinished(sessionId) {
+  const res = await fetch(
+    `${API}/api/public/embed/sessions/${encodeURIComponent(sessionId)}/status`,
+    { credentials: "omit" },
+  );
+  if (!res.ok) throw new Error(`status HTTP ${res.status}`);
+  const data = await res.json();
+  if (!data.registered) return { done: false, reason: "pending" };
+  if (data.finished) return { done: true, data };
+  return { done: false, reason: "running" };
+}
+
+const timer = setInterval(async () => {
+  try {
+    const poll = await pollUntilFinished(sessionId);
+    if (poll.done) {
+      clearInterval(timer);
+      const output = await fetch(
+        `${API}/api/public/embed/sessions/${encodeURIComponent(sessionId)}/result`,
+        { credentials: "omit" },
+      ).then((r) => r.json());
+      console.log("问答已结束", output.generated_text, output.generated_files);
+    }
+  } catch (e) {
+    console.error(e);
+  }
+}, 2000);
+```
+
+### 5.3 跨域注意
+
+父页面从浏览器 `fetch` Gateway（如 `http://47.88.25.99:7001/`）时，**Origin 必须是后端 CORS 白名单里的完整地址**（含协议、主机、端口），与 API 地址是否写 `localhost` / `127.0.0.1` 无关。
+
+**本地开发**（前端默认 `5174`）请在 Gateway 环境变量中配置：
+
+```bash
+# offline-backend-20260512/.env 或启动脚本注入
+GATEWAY_CORS_ORIGINS=http://localhost:5174,http://127.0.0.1:5174,http://localhost:5173,http://127.0.0.1:5173
+```
+
+修改后**重启 Gateway**（`make dev` / `make gateway`）。若父页面部署在其它域名，把该域名的 origin 一并加入逗号分隔列表。
+
+临时调试（勿用于公网生产）：
+
+```bash
+GATEWAY_CORS_ALLOW_ALL=1
+```
+
+常见报错：`No 'Access-Control-Allow-Origin' header` → 当前页面的 origin 未出现在 `GATEWAY_CORS_ORIGINS` 中。
+
+### 5.4 其它部署注意
+
+---
+
+## 6. 部署与数据库
+
+1. **跑迁移**（SQL 持久化后端）：
+
+   ```bash
+   cd offline-backend-20260512/backend
+   # 按项目惯例执行 alembic upgrade head
+   ```
+
+   表：`embed_sessions(session_id PK, thread_id, created_at, updated_at)`。
+
+2. **重启 Gateway**，确认路由已挂载：`public_embed.router`（`app/gateway/app.py`）。
+
+3. **前端构建** 后，将嵌入地址配给第三方；`VITE_BACKEND_BASE_URL` 指向可达的 Gateway。
+
+无 SQL 时开发环境会退化为 **内存** `MemoryEmbedSessionStore`（进程重启后映射丢失）；生产请使用持久化库。
+
+---
+
+## 7. 安全说明
+
+- `sessionId` 与 `thread_id` 均视为 **不透明能力令牌**：知晓即可查询状态（公开 API **无登录**）。
+- 建议：父系统自行生成不可猜测的 UUID；敏感场景在贵司 API 网关再加鉴权或 IP 限制。
+- 登记接口为 **POST upsert**，不校验「session 是否属于某租户」——若需多租户隔离，请在业务层约定 `sessionId` 命名空间或增加网关校验。
+
+---
+
+## 8. 与主聊天 `/page/workspace/chats` 的差异
+
+| 项目 | 主聊天 | iframe 嵌入 |
+|------|--------|-------------|
+| 路由 | `/page/workspace/chats/:id` | `/embed/chats/:id` |
+| 布局 | 完整 Workspace + 输入框 | 仅消息区 + 产物栏 |
+| 登录 | 常规登录流 | URL `username` 自动 `login/username` |
+| 首条消息 | 用户输入 | URL `message` 自动发送 |
+| 完成态查询 | 无公开 API | `sessionId` + `/api/public/embed/sessions/.../status` |
+
+能力上仍走同一 `useThreadStream` + `lead_agent` 流式链路，沙箱与产物行为与主聊天一致。
+
+---
+
+## 9. 常见问题
+
+**Q：`registered` 一直为 false？**  
+A：检查 iframe URL 是否带 `sessionId`；子页是否登录成功；Network 里是否有 `POST /api/public/embed/sessions` 且 200。
+
+**Q：`finished` 一直 false？**  
+A：可能仍在流式生成（`has_active_run: true`），或 agent 进入澄清（`thread_status: interrupted`）。嵌入模式无底部输入框，澄清需产品侧另行处理或避免触发澄清类工具。
+
+**Q：父页面能否不用轮询？**  
+A：当前标准方案为公开 GET 轮询。若同源可考虑 `postMessage` 扩展（未默认实现）。
+
+**Q：能否继续用已有 thread_id 嵌入？**  
+A：可以：`#/embed/chats/{thread_id}?sessionId=...`，可选再带 `message` 追加一轮；登记会在已知 id 上 upsert。
+
+---
+
+## 10. 变更记录
+
+| 日期 | 说明 |
+|------|------|
+| 2026-06-02 | 初版：iframe 嵌入路由、`sessionId` 映射表、公开登记与状态 API |
+| 2026-06-02 | 新增 `GET /sessions/{session_id}/result`：返回 messages、generated_text、generated_files |

frontend-web/docs/embed-public-pages-theme.md

@@ -0,0 +1,154 @@
+# 公开页 · iframe 嵌入外观对接说明（主题 / 背景色）
+
+本文档面向**嵌入方（宿主系统）**，说明如何在用 `<iframe>` 嵌入 DeerFlow 公开页时，从外部控制页面的**整体明暗主题（light/dark）**与**背景色 / 文字色**，使其与宿主站点的视觉风格保持一致。
+
+前端实现见：`src/core/embed/background.ts`（参数解析与 postMessage 监听）、`src/App.tsx`（主题接入 `forcedTheme`）。
+
+---
+
+## 0. 速读
+
+| 想做什么 | 怎么做 |
+|----------|--------|
+| 嵌入时指定深色主题 | iframe `src` 加 `?theme=dark` |
+| 嵌入时指定背景/文字色 | iframe `src` 加 `?bg=%23001529&text=%23ffffff`（`#` 需编码为 `%23`） |
+| 宿主切主题时同步切换 | `postMessage({ type: "deerflow:set-theme", theme: "dark" }, "*")` |
+| 宿主动态改背景色 | `postMessage({ type: "deerflow:set-bg", bg: "#001529", text: "#fff" }, "*")` |
+| 什么都不传 | 页面使用 DeerFlow 自带默认配色，互不影响 |
+
+---
+
+## 1. 适用页面
+
+以下公开页（免登录、只读）均支持本文档的全部参数：
+
+| 页面 | 路由 |
+|------|------|
+| 会话分享页 | `/#/share/{shareCode}` |
+| 圆桌分享页 | `/#/roundtable-share/{shareCode}`、`/#/roundtable-share/{shareCode}/report` |
+| 用户排行榜 | `/#/public/leaderboard` |
+| 定时任务公开页 | `/#/public/scheduled-tasks/{taskId}`（含 `/runs/{runId}/fullscreen` 全屏页） |
+
+> 注意：站点使用 **hash 路由**，路径在 `#` 之后。
+> 嵌入聊天页（`/#/embed/chats/*`、`/#/embed/roundtable`）有自己的主题约定，见 `embed-iframe-chat.md`，不在本文范围内。
+
+---
+
+## 2. URL 查询参数（嵌入时一次性指定）
+
+### 2.1 参数列表
+
+| 参数 | 别名 | 作用 | 合法值 |
+|------|------|------|--------|
+| `theme` | — | 切整体明暗主题 | 见 2.2 取值映射表 |
+| `bg` | `background` | 页面根容器背景色 | 见 2.3 颜色格式 |
+| `text` | `fg` | 页面根容器文字色 | 见 2.3 颜色格式 |
+
+三个参数相互独立，可任意组合；不传或传非法值时该项忽略、沿用默认。
+
+### 2.2 `theme` 取值映射
+
+| 传入值（不区分大小写） | 实际主题 |
+|------|------|
+| `dark`、`dark-blue`、`深蓝`、`深色` | 深色 |
+| `light`、`red`、`红白`、`浅色` | 浅色 |
+| 其他 / 不传 | 忽略，沿用站内默认（浅色） |
+
+### 2.3 颜色格式（`bg` / `text`）
+
+颜色值经过白名单校验，仅接受以下写法，其余一律丢弃（防注入）：
+
+- **hex**：`#fff`、`#ffffffcc` 等 3/4/6/8 位（`#` 可省略；URL 里 `#` 必须编码为 `%23`）
+- **函数式**：`rgb()` / `rgba()` / `hsl()` / `hsla()`，括号内仅允许数字、逗号、百分号、空格、`/`
+- **命名色**：纯英文字母，如 `white`、`transparent`
+
+### 2.4 参数位置
+
+参数放在 hash 路由之后（推荐）或 `#` 之前都能识别；两处都传时**hash 路由内的优先**：
+
+```
+https://<host>/#/public/leaderboard?theme=dark          ← 推荐
+https://<host>/?theme=dark#/public/leaderboard          ← 也支持
+```
+
+### 2.5 示例
+
+```html
+<!-- 深色主题 -->
+<iframe src="https://<host>/#/public/leaderboard?theme=dark"></iframe>
+
+<!-- 浅色主题 + 自定义背景与文字色（# 编码为 %23） -->
+<iframe src="https://<host>/#/share/Ab3xYz?theme=light&bg=%23f5f7fa&text=%23333333"></iframe>
+
+<!-- 主题与背景叠加：整页走深色变量，根背景用宿主品牌色 -->
+<iframe src="https://<host>/#/roundtable-share/Ab3xYz?theme=dark&bg=%23001529"></iframe>
+```
+
+---
+
+## 3. postMessage（嵌入后动态切换）
+
+适用于宿主站点支持用户切主题、需要 iframe 实时跟随的场景。向 iframe 的 `contentWindow` 发消息即可，**无需等待子页面回执**（监听器在应用挂载时注册）。
+
+### 3.1 消息格式
+
+```js
+const frame = document.getElementById("deerflow-frame");
+
+// 切整体明暗主题（theme 取值同 2.2）
+frame.contentWindow.postMessage({ type: "deerflow:set-theme", theme: "dark" }, "*");
+
+// 改背景色 / 文字色（字段名与 URL 参数一致，bg/background、text/fg 均可）
+frame.contentWindow.postMessage({ type: "deerflow:set-bg", bg: "#001529", text: "#fff" }, "*");
+// 兼容别名：type 也可写 "deerflow:set-background"
+```
+
+说明：
+
+- 两类消息相互独立，可只发其一；`set-bg` 里 `bg`、`text` 也可只传其一，未传的字段保持当前值。
+- 非法颜色值 / 不认识的 `theme` 取值会被忽略，不会清空已有设置。
+- targetOrigin 建议按需收紧（写 DeerFlow 站点的 origin 而非 `"*"`）。
+
+### 3.2 宿主主题联动示例
+
+```js
+function syncDeerflowTheme(isDark) {
+  const win = document.getElementById("deerflow-frame").contentWindow;
+  win.postMessage({ type: "deerflow:set-theme", theme: isDark ? "dark" : "light" }, "*");
+  win.postMessage(
+    { type: "deerflow:set-bg", bg: isDark ? "#001529" : "#ffffff" },
+    "*",
+  );
+}
+
+// iframe 首次加载用 URL 参数兜底，之后切换走 postMessage
+myThemeStore.subscribe((theme) => syncDeerflowTheme(theme === "dark"));
+```
+
+---
+
+## 4. 优先级与默认行为
+
+同一项配置多处传入时，按以下优先级取值（高 → 低）：
+
+1. **postMessage** 动态设置的值
+2. hash 路由内的 URL 参数（`#/路由?theme=...`）
+3. `#` 之前的 URL 参数（`?theme=...#/路由`）
+4. 都没传 → DeerFlow 默认配色（浅色主题 + 页面自带 Tailwind 配色）
+
+其他保证：
+
+- 外部主题只影响**当前 iframe 的渲染**，不写 localStorage——不会污染用户直接访问 DeerFlow 主站时自己选择的主题。
+- `bg`/`text` 是内联样式，作用在页面根容器上，优先级高于主题变量；与 `theme` 叠加时以 `bg`/`text` 为准。
+
+---
+
+## 5. 常见问题排查
+
+| 现象 | 排查 |
+|------|------|
+| `theme=dark` 不生效 | 确认路由属于第 1 节列出的公开页；确认参数拼在 hash 路由后（`/#/share/xx?theme=dark`），而不是写成了 `/#/share/xx#theme=dark` |
+| `bg=#fff` 不生效 | URL 里 `#` 没编码会被浏览器截断，必须写 `%23fff`；或直接省略 `#` 写 `bg=fff` |
+| postMessage 无反应 | 确认消息体是对象且 `type` 拼写为 `deerflow:set-theme` / `deerflow:set-bg`；确认在 iframe `load` 之后发送 |
+| 颜色被忽略 | 检查是否符合 2.3 白名单格式（如 `linear-gradient(...)` 等复杂值不支持） |
+| 主题切了但个别区域颜色没变 | 该区域可能使用了固定配色；把页面路由与截图反馈给 DeerFlow 维护方补充 `dark:` 样式 |

frontend-web/docs/hebing.md

@@ -1,140 +0,0 @@
-# App.tsx 路由与页面结构重构需求（首页与业务页分离）
-
-## 一、需求背景
-
-当前 `frontend-web/src/App.tsx` 同时承载了：
-
-1. 登录/首页相关路由（如 `/login`、`/landing`）
-2. 工作台业务相关路由（如 `/workspace/chats`、`/workspace/agents`、`/workspace/scheduled/*`）
-3. 业务页所需布局与运行时包装（`WorkspaceLayout`、`ChatRuntime`）
-
-这会导致 `App.tsx` 过重，职责不够单一，不利于后续维护和扩展。
-
----
-
-## 二、目标（你提出的核心诉求）
-
-你希望：
-
-1. **除了登录与首页入口内容外**，将 `App.tsx` 中其余业务页面路由整体迁移到 `pages` 下一个新组件中。
-2. 再创建一个“承接导航/入口”的页面（或路由容器），用于放置这些导航逻辑。
-3. `App.tsx` 最终只保留顶层路由分发和基础 Provider，变得更薄。
-
-> 你提到“`App.tsx 74-75 login`”，可理解为：保留登录/首页相关入口，其他工作台内容抽离。
-
----
-
-## 三、重构范围
-
-### 1）保留在 `App.tsx` 的内容
-
-- 全局 Provider：`HashRouter`、`AppProviders`
-- 登录/首页路由：
-  - `/`
-  - `/login`
-  - `/login/:username`
-  - `/landing`
-- 404 路由（可留在 `App.tsx` 或交给新路由容器统一处理，二选一）
-
-### 2）迁移出 `App.tsx` 的内容
-
-将以下与工作台有关的路由从 `App.tsx` 抽离：
-
-- `/workspace`（重定向）
-- `/workspace/chats`
-- `/workspace/chats/:thread_id`
-- `/workspace/agents`
-- `/workspace/agents/new`
-- `/workspace/agents/:agent_id/chats`（重定向）
-- `/workspace/agents/:agent_id/chats/:thread_id`
-- `/workspace/scheduled`
-- `/workspace/scheduled/tasks`
-- `/workspace/scheduled/runs/:run_id`
-
-以及配套的包装组件职责：
-
-- `WorkspaceLayout`
-- `ChatRuntime`
-
----
-
-## 四、建议的新结构（方案）
-
-## 方案 A（推荐）：新增“业务路由容器组件”
-
-在 `pages` 下新增一个路由容器组件，例如：
-
-- `src/pages/WorkspaceRoutes.tsx`（或 `src/pages/AppWorkspaceRoutes.tsx`）
-
-职责：
-- 专门维护 `/workspace/*` 相关路由
-- 内部统一使用 `WorkspaceLayout` 与 `ChatRuntime`
-- 输出一个可被 `App.tsx` 挂载的路由节点
-
-同时在 `App.tsx` 里只保留：
-- 登录/首页/404
-- 一个 `Route path="/workspace/*" element={<WorkspaceRoutes />} />`
-
----
-
-## 五、“再建立一个页面放置导航”的落地解释
-
-你说的“建立一个页面放置这些导航”，可以有两种理解：
-
-1. **路由容器页（推荐）**：
-   - 不强调视觉 UI，重点是集中管理导航与路由跳转规则。
-   - 即上面的 `WorkspaceRoutes.tsx`。
-
-2. **可见的导航页（可选）**：
-   - 例如新建 `WorkspaceHomePage.tsx`，展示聊天/Agents/定时任务入口按钮。
-   - 路由上把 `/workspace` 指向该页，而不是直接重定向到 `/workspace/chats/new`。
-
-当前从你的描述看，优先建议第 1 种（先做结构整理），之后若有产品需求再做第 2 种可见导航页。
-
----
-
-## 六、实施步骤（开发任务拆解）
-
-1. 新建 `WorkspaceRoutes` 组件（`pages` 目录下）。
-2. 把所有 `/workspace/*` 路由从 `App.tsx` 搬入该组件。
-3. 把 `WorkspaceLayout` 与 `ChatRuntime` 移入该组件（或抽到共享 layout/runtime 文件）。
-4. 在 `App.tsx` 中保留登录/首页路由，并挂载 `/workspace/*` 到新组件。
-5. 校验以下访问路径行为一致：
-   - `/workspace` 重定向
-   - chats/agents/scheduled 各页面可正常进入
-   - 动态参数路由（`thread_id`、`agent_id`、`run_id`）正常
-   - 404 不受影响
-6. 运行前端并做手工回归。
-
----
-
-## 七、验收标准
-
-1. `App.tsx` 明显瘦身，主要负责顶层入口路由。
-2. `/workspace/*` 全部由新建组件统一管理。
-3. 功能行为与改造前一致（或符合新定义）。
-4. 代码可读性提升：登录入口与业务入口职责分离。
-
----
-
-## 八、注意事项
-
-1. 当前项目使用 `HashRouter`，路由写法需保持兼容。
-2. `Navigate` 重定向逻辑要完整迁移，避免出现死循环或空白页。
-3. `WorkspaceLayout` 与 `ChatRuntime` 的包裹层级不能错，否则可能影响侧边栏、输入区、子任务/Artifacts 状态。
-4. 若后续再加模块（例如 `/workspace/settings`），优先在 `WorkspaceRoutes` 中扩展。
-
----
-
-## 九、建议的命名（可直接采用）
-
-- 新增组件文件：`src/pages/WorkspaceRoutes.tsx`
-- （可选）可见导航页：`src/pages/WorkspaceHomePage.tsx`
-
----
-
-## 十、后续可选优化
-
-1. 将 `WorkspaceLayout` 抽到 `src/layouts/WorkspaceLayout.tsx`。
-2. 将 `ChatRuntime` 抽到 `src/runtime/ChatRuntime.tsx`。
-3. 把路由常量集中到 `src/core/router/paths.ts`，减少硬编码路径。

frontend-web/docs/multi-agent-background-run-dev.md

@@ -0,0 +1,514 @@
+# 多智能体规划 · 后台挂起执行 + 进度可视化 —— 分步实现方案
+
+> 目标：在「多智能体规划」第二步增加**后台挂起**能力——把当前任务挂到后台，自动一路跑到
+> 最后一步（Step3 结果绘制完成）为止；历史记录下拉框里进行中的任务显示加载动画；点击进行中
+> 的任务弹出一个**大弹窗**，里面是**横向的智能体派活链路流程图**（节点 = 各席位智能体，图标 +
+> 名称，不同颜色，正在发言的节点和它的连接线带加载动画）；弹窗里有「查看」按钮，点击进入正在
+> 进行中的任务实时观察。
+
+---
+
+## 0. 现状与架构事实（动手前必读）
+
+研究自现有代码，决定了整套方案的形态。**关键结论：当前编排循环跑在前端，离开页面即中断。**
+
+### 0.1 前端现状
+
+| 事实 | 位置 |
+|------|------|
+| Step2 编排循环（leader → 顺序派 special → leader … 直到 `dispatched===[]` 共识 / `MAX_CYCLES=8`）**完全由前端 hook 驱动** | `src/roundtable-planning/hooks/useStep2Orchestration.ts:992-1204`（recommend）、`1228-1439`（chain） |
+| 循环由 `currentStep===2` 的 `useEffect` 启停；离开 Step2 的 cleanup 会 `orchestrationCancelRef.current=true` + `abortAllInFlight()` 中断 | `useStep2Orchestration.ts:1468-1541`（尤其 cleanup `1534-1537`、`1471-1477`） |
+| 共识判定：`leaderRes.dispatched.length===0` → `setHasConsensus(true)` | `useStep2Orchestration.ts:1091-1099` |
+| 进入 Step3：手动点按钮，前置 `hasConsensus===true` | `Step2Panel.tsx:370-381`、`RoundtablePlanningPage.tsx:586-595` |
+| Step3「结果绘制」：前端流式调 `roundtable-report` 智能体，写出 `outputs/方案总览.html`，`phase→"done"` 即完成 | `src/roundtable-planning/hooks/useStep3Report.ts:36,51,165,560-596,636-652` |
+| 草稿持久化：`/api/roundtable-drafts`，含 step1/step2/step3 三段快照 + `furthestStep(1|2|3)`，**无显式 status 字段** | `src/roundtable-planning/api/drafts.ts:25-110,112,184-225` |
+| 历史下拉 UI（触发按钮 + 列表 + 重命名/删除） | `RoundtablePlanningPage.tsx:771-892` |
+| 自动保存触发点（Step1 回复完 / Step2 每轮气泡收尾 / Step3 报告保存 / 步骤前进） | `useDraftPersistence.ts:248-316` |
+| 加载草稿恢复：`handleLoadDraft` → `getDraft` → `cancelAllStreams` → hydrate → `setCurrentStep(furthestStep)` | `useDraftPersistence.ts:308-368` |
+
+### 0.2 后端现状
+
+| 事实 | 位置 |
+|------|------|
+| `/api/multi-agent/init`：为各席位并行建 thread + 单例总控 `roundtable-coordinator`，SSE 返回 `seat_ready`/`coordinator_ready`/`init_done(thread_ids)` | `app/gateway/routers/multi_agent.py:647-823` |
+| `/api/multi-agent/run/stream`：驱动**单轮** leader 或 special 的 LLM 执行，末尾 JSON 帧 `status`（派活列表 / `[]` 共识 / `clarification` / `error`） | `multi_agent.py:1076-1142` |
+| `/api/multi-agent/report/init`：为 Step3 报告建 thread | `multi_agent.py`（report/init） |
+| **后端不存在编排循环**——leader 派活由前端解释后再逐个发 `run/stream`；后端只做单轮执行 + 把派活/完成「广播」追加进各 thread 历史消息 | `multi_agent.py:24-29,487-502,1108-1142` |
+| 派活格式：`agent_orchestration` 工具调用 `{agent_name, task}`（旧式 bash 解析兼容） | `multi_agent.py:525-552` |
+
+### 0.3 可复用模板：AI 写作的「后台多阶段流程」
+
+AI 写作已经把「后台跑多阶段流程 + 前端 SSE 订阅 + 可 resume + 定时清理」跑通了，**圆桌后台作业直接照搬这套**：
+
+| 模板要素 | 位置 |
+|------|------|
+| LangGraph 图驱动多阶段（researching/writing_outline/writing_draft/reviewing/…），条件路由推进，`interrupt()` 暂停点等用户输入 | `packages/harness/deerflow/agents/ai_writing/graph.py`、`nodes/*`（`pause_material_confirm` 等 `45-290`） |
+| Session 持久化表 `ai_writing_sessions`：`id/user_id/title/status/draft_*/transcript(LONGTEXT)/...`，`status∈{in_progress,done,error}` | `packages/harness/deerflow/persistence/ai_writing_sessions/model.py:14-39` |
+| `transcript` 用 `PortableLongText`（MySQL LONGTEXT，避开 64KB），时间用 `BeijingDateTime` | 同上 `27-38` |
+| 进度走 LangGraph Server 标准流 `stream_mode=["messages-tuple","values"]`，**graph 在 langgraph runtime 里跑，任意 worker 可 join stream**（这是后台健壮性的关键） | `ai_writing.py:1-17`、`langgraph.json:16-18` |
+| Checkpointer 共享 `AsyncSqliteSaver`，落 `.deer-flow/data/checkpoints.db`（需挂数据卷） | `runtime/checkpointer/async_provider.py` |
+| Cleanup cron（leader 文件锁、活跃保护、先删 CP 再删 DB、admin 手动触发） | `app/gateway/ai_writing_cleanup.py:26,34-59,111-135,193-215,307-367` |
+| **多 worker 坑**：模块级内存 dict（`_event_queues`）每 worker 一份会丢会话；SSE 进程内直调会整段 buffer。解法：状态进 DB+checkpointer、SSE 走真 TCP loopback `127.0.0.1`（`trust_env=False` 禁代理） | `multi_agent.py:271-293`、`AIWritingPage.tsx` 文件头注释 §3/§5 |
+
+### 0.4 决策（已与产品确认）
+
+1. **后端真后台执行**：把编排循环搬到后端 run，刷新 / 关页 / 换设备都不中断。
+2. **流程图节点 = 智能体派活链路**：横向排列的席位节点，正在发言的节点 + 连接线加载动画。
+
+> ⚠️ **本方案最大的工作量在 Phase 2**：把目前跑在前端 TS 里的编排循环（`runOrchestration`/`runChainOrchestration`）
+> 移植成一个后端 **LangGraph「圆桌总控编排图」**。这是与 AI 写作一致、可在 LangGraph runtime 里
+> 后台跑且天然 checkpoint 的健壮路径。下文每个阶段都给出验收标准，可独立提测。
+
+---
+
+## 1. 总体架构
+
+```
+┌─────────────────────────────── 前端 (frontend-web) ───────────────────────────────┐
+│  Step2Panel ──「后台挂起」按钮──▶ POST /api/roundtable-jobs (start)                  │
+│  HistoryDropdown ── 进行中任务显示 spinner ──▶ 点击 ──▶ DispatchChainModal(大弹窗)    │
+│        DispatchChainModal ── 订阅 GET /api/roundtable-jobs/{id}/stream(SSE)          │
+│              横向派活链路流程图(节点=席位, 活动节点+连线动画) ──「查看」──▶ 进入任务实时观察 │
+└───────────────────────────────────────────────────────────────────────────────────┘
+                                   │ SSE 进度 / 快照
+┌─────────────────────────────── 后端 (backend) ─────────────────────────────────────┐
+│  /api/roundtable-jobs  路由层(start/get/stream/resume/cancel) ── 仿 ai_writing.py     │
+│        │ 启动后台 run                                                                 │
+│  LangGraph「圆桌总控编排图」 roundtable_orchestrator  ── 仿 ai_writing graph           │
+│     init → leader_call → parse_dispatch → dispatch_seats(顺序) → loop ↺               │
+│         → consensus → report_draw(写 HTML) → done   （clarification 点 interrupt())   │
+│        │ 每次状态转移持久化进度                                                        │
+│  roundtable_jobs 表(status/phase/dispatch_chain/active_speaker/...) + 共享 checkpointer│
+│  cleanup cron (仿 ai_writing_cleanup.py)                                              │
+└───────────────────────────────────────────────────────────────────────────────────┘
+```
+
+**核心思路**：后台作业 = 一个 LangGraph 图的一次 run。图节点内部复用现有的单轮执行能力
+（`multi_agent.py` 里 leader/special 的 run 逻辑），把「解释派活 → 顺序派活 → 回到 leader」的
+循环从前端搬进图节点。前端从「驱动者」退化为「观察者」：通过 SSE 订阅进度渲染。
+
+---
+
+## 2. 数据契约（前后端共享，先定义后实现）
+
+### 2.1 作业状态机 `JobStatus`
+
+```
+queued          # 已创建，等待 worker 拉起
+running          # 编排进行中（Step2 派活循环 / Step3 绘制）
+awaiting_input   # 命中 clarification，等用户回答（interrupt 挂起）
+done             # 已跑到 Step3 绘制完成
+error            # 出错终止
+cancelled        # 用户取消
+```
+
+### 2.2 作业阶段 `JobPhase`（细化给流程图/进度条用）
+
+```
+initializing       # 建 thread / 总控就绪
+leader_thinking    # 总控在决策派活
+dispatching        # 正在顺序派活给席位（配合 active_speaker）
+consensus          # 共识达成（dispatched=[]）
+report_drawing     # Step3 报告绘制中
+report_done        # 绘制完成
+```
+
+### 2.3 派活链路节点 `DispatchChainNode`（流程图核心数据）
+
+```ts
+interface DispatchChainNode {
+  agentId: string;        // 席位 agent_id（小写）
+  name: string;           // 显示名
+  avatarType: string;     // 复用 getAvatarTypeFor(agentId, index) → 决定颜色
+  order: number;          // 横向排列次序（chain 模式=链条顺序；recommend 模式=席位/发言顺序）
+  state: 'pending' | 'active' | 'done';  // 节点状态（驱动颜色/动画）
+  lastSpokeCycle?: number;               // 最近发言轮次（可选，做 tooltip）
+}
+```
+
+### 2.4 进度事件 `JobProgressEvent`（SSE 推送的归一化事件）
+
+```ts
+type JobProgressEvent =
+  | { type: 'status';   status: JobStatus }
+  | { type: 'phase';    phase: JobPhase; cycle: number }
+  | { type: 'chain';    nodes: DispatchChainNode[] }           // 派活链路全量/增量
+  | { type: 'active';   agentId: string | null }               // 当前发言席位（null=总控/无）
+  | { type: 'consensus'; percentage: number }
+  | { type: 'dialogue'; bubble: Step2DialogueLike }            // 新增/收尾的对话气泡（供「查看」实时渲染）
+  | { type: 'clarification'; question: string }                // 命中澄清
+  | { type: 'done';     step3: DraftStep3Snapshot }            // 终态：最终报告快照
+  | { type: 'error';    detail: string };
+```
+
+> SSE 通道可直接复用 LangGraph Server 的 `values` 流（图状态快照），由前端 hook 把 `values`
+> 映射成上述归一化事件；也可在路由层做映射后再下发。**推荐前端映射**（少一层后端耦合）。
+
+### 2.5 作业记录 `RoundtableJob`（持久化 + 列表展示）
+
+```ts
+interface RoundtableJob {
+  id: string;
+  draftId: string;            // 关联的草稿
+  userId: string;
+  status: JobStatus;
+  phase: JobPhase;
+  cycle: number;              // 当前轮次（0..MAX_CYCLES）
+  dispatchChain: DispatchChainNode[];
+  activeAgentId: string | null;
+  consensusPercentage: number;
+  pendingClarification: string | null;
+  threadIds: Record<string,string> | null;  // 复用 ThreadIdMap
+  coordinatorName: string | null;
+  orchestrationMode: 'recommend' | 'chain';
+  chain?: { id: string; title: string } | null;
+  error: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+```
+
+---
+
+## Phase 1 —— 后端：圆桌作业持久化模型
+
+**目标**：建一张 `roundtable_jobs` 表（仿 `ai_writing_sessions`），存作业状态/阶段/派活链路，
+并在 `roundtable_drafts` 列表里能 join 出当前作业状态。
+
+**涉及文件（新增/改）**
+- 新增 `packages/harness/deerflow/persistence/roundtable_jobs/model.py`（ORM 模型，仿 `ai_writing_sessions/model.py:14-39`）
+- 新增 `.../roundtable_jobs/sql.py`（Repository：`create / get / update_progress / list_by_user / list_older_than / delete`，仿 `ai_writing_sessions/sql.py`）
+- 新增 alembic 迁移 `persistence/migrations/versions/<date>_create_roundtable_jobs.py`
+- 改 `roundtable_drafts` 的列表查询：返回里带上 `status`/`jobId`（LEFT JOIN roundtable_jobs，或在 draft 行上冗余一个 `status` 字段，二选一，见下）
+
+**步骤**
+1. 字段设计（对齐 §2.5）：`id(PK)`、`draft_id`、`user_id`、`status`、`phase`、`cycle(Int)`、
+   `dispatch_chain(PortableLongText/JSON)`、`active_agent_id`、`consensus_percentage(Int)`、
+   `pending_clarification(Text)`、`thread_ids(JSON)`、`coordinator_name`、`orchestration_mode`、
+   `chain(JSON)`、`error(Text)`、`created_at/updated_at(BeijingDateTime)`。
+2. `dispatch_chain` / `thread_ids` / `chain` 用 `PortableLongText` 存 JSON 字符串，repo 层序列化。
+3. 列表 join：给 `DraftMeta` 增加 `status?: JobStatus` 与 `jobId?: string`。
+   **推荐方案**：草稿与作业 1:1（一个草稿最多一个活跃作业），在 draft 列表查询 LEFT JOIN
+   `roundtable_jobs` 取最新作业的 `status`。
+4. 索引：`(user_id, updated_at)`、`(draft_id)`、`(status)`（cleanup/列表用）。
+
+**验收**
+- 迁移可 `alembic upgrade head` 跑通，MySQL 上 `dispatch_chain` 为 `longtext`。
+- 单测：create→update_progress→get 往返；`list_by_user` 按 `updated_at` 倒序；`list_older_than` 分批。
+
+---
+
+## Phase 2 —— 后端：圆桌总控编排 LangGraph 图（核心 / 最大工作量）
+
+**目标**：把前端的编排循环移植成一个后端 LangGraph 图，可在 LangGraph runtime 里后台跑、天然
+checkpoint，一路跑到 Step3 绘制完成。
+
+**涉及文件（新增）**
+- `packages/harness/deerflow/agents/roundtable_orchestrator/graph.py`（图装配，仿 `ai_writing/graph.py`）
+- `.../roundtable_orchestrator/state.py`（图状态 schema：intent、selectedAgents、threadIds、coordinatorName、
+  mode/chain、dialogues、dispatchChain、activeAgentId、cycle、consensus、phase、step3 等）
+- `.../roundtable_orchestrator/nodes/*.py`（各节点）
+- 在 `langgraph.json` 注册新 assistant `roundtable_orchestrator`（仿 ai_writing assistant 注册，参考 `langgraph.json:16-18`）
+
+**图节点设计（把前端循环逐段翻译过来）**
+
+| 节点 | 职责 | 对应前端逻辑 |
+|------|------|------|
+| `init` | 复用 `_create_thread_direct` 批量建席位 thread + 总控就绪（或接收前端已建好的 `threadIds` 直接用） | `useStep2Orchestration.ts:1485-1531` / `multi_agent.py:647-823` |
+| `leader_call` | 跑一轮总控（agent_type=leader），拿 `status`（派活列表 / `[]` / `clarification`） | 单轮逻辑 `multi_agent.py:1076-1142` |
+| `route_after_leader`（条件边） | `clarification`→`interrupt`；有派活→`dispatch_seats`；`[]`→`consensus` | `useStep2Orchestration.ts:1091-1181` |
+| `dispatch_seats` | **顺序**派活：对 dispatched 里每个席位依次跑 special run；每开始一个就更新 `activeAgentId` + 进度持久化 | `useStep2Orchestration.ts:1101-1181`（务必串行，勿并行，详见前端 §5.4 注释） |
+| `clarification_pause` | `interrupt()` 挂起，`status→awaiting_input`，写 `pending_clarification` | 仿 ai_writing `pause_*` `45-290` |
+| `consensus` | `setHasConsensus`、`consensus=100`，落库后进入 `report_draw` | `1091-1099` |
+| `report_draw` | 跑 `roundtable-report`（先 report/init 建 thread），流式写 `outputs/方案总览.html`，产出 `DraftStep3Snapshot` | `useStep3Report.ts:91-149,636-652,560-596` |
+| `done` | `status→done`、写 `step3` 进作业 + 回写草稿 step3 快照 | `RoundtablePlanningPage.tsx:613-617` |
+
+**关键实现要点**
+1. **复用单轮执行**：节点内部不要重写 LLM 调用，抽出 `multi_agent.py` 里 leader/special/report 的
+   单轮 run 为可被图节点直接 `await` 的内部函数（去掉 HTTP 层，进程内调 LangGraph）。
+2. **派活广播**：保留现有把「总控给 X 派了活 / X 完成」追加进各 thread 历史的广播
+   （`multi_agent.py:487-502`），让席位读到全局上下文。
+3. **MAX_CYCLES 兜底**：图里维护 `cycle`，≥8 强制收敛（对齐 `roundtable-constants.ts:13`）。
+4. **chain 模式**：`orchestration_mode==='chain'` 时按 `chain.seats` 固定顺序派活，跳过总控自由决策的
+   部分（对齐 `runChainOrchestration` `1228-1439`）。
+5. **进度落库**：每个节点结束 `update_progress(jobId, {phase, cycle, dispatchChain, activeAgentId,
+   consensus, dialogues_delta})`，前端 SSE 才有实时数据。
+6. **dialogues 累积**：把每轮气泡写进图状态 `dialogues`，既供「查看」实时渲染，也供作业结束回写草稿 step2。
+
+**验收**
+- 用脚本（仿 `scripts/probe_ai_writing_assistant.py`）直接对图发起一次 run，不开前端，能从 intent +
+  selectedAgents 一路跑到写出 `方案总览.html`，作业 `status` 终态 `done`。
+- 命中 clarification 时图 `interrupt`，`status=awaiting_input`，`pending_clarification` 有值。
+- chain 模式按链条顺序派活，recommend 模式由总控自由派活，两条路径都能收敛。
+
+---
+
+## Phase 3 —— 后端：作业控制 + 进度 SSE 接口
+
+**目标**：暴露 start/get/stream/resume/cancel，后台 run 走 LangGraph Server（任意 worker 可 join）。
+
+**涉及文件（新增/改）**
+- 新增 `app/gateway/routers/roundtable_jobs.py`（仿 `ai_writing.py` 的 CRUD + 控制壳）
+- 在 gateway `app.py` 注册路由
+- 新增 `app/gateway/roundtable_jobs_cleanup.py`（仿 `ai_writing_cleanup.py`）+ 在启动处挂 cron
+
+**接口契约**
+
+| 方法 | 路径 | 说明 |
+|------|------|------|
+| `POST` | `/api/roundtable-jobs` | 入参：`{draftId, intent, selectedAgents, threadIds?, coordinatorName?, model, orchestrationMode, chain?}`。建作业记录(`queued`) + 启动图 run（LangGraph Server thread），返回 `RoundtableJob` |
+| `GET` | `/api/roundtable-jobs/{id}` | 作业快照（轮询兜底 / 弹窗首帧） |
+| `GET` | `/api/roundtable-jobs/{id}/stream` | SSE 进度流：透传图 `values`/`messages-tuple`，或映射成 §2.4 事件下发。**走真 TCP loopback**（`multi_agent.py:271-293`），禁代理 |
+| `POST` | `/api/roundtable-jobs/{id}/resume` | 入参 `{answer}`，回填 clarification → 图 resume，`status→running` |
+| `POST` | `/api/roundtable-jobs/{id}/cancel` | 取消图 run，`status→cancelled` |
+| `GET` | `/api/roundtable-jobs?draftId=` | 按草稿查活跃作业（页面恢复用） |
+| `POST` | `/api/roundtable-jobs/admin/cleanup` | 管理员手动清理（仿 ai_writing admin cleanup `307-367`） |
+
+**多 worker 健壮性（务必遵守，照搬 ai_writing 教训）**
+- 作业状态只存 **DB + checkpointer**，**不要**用模块级内存 dict 存 per-session 状态。
+- SSE 必须经真 TCP `127.0.0.1` loopback，不能 `httpx.ASGITransport(app=...)` 进程内直调（会整段 buffer）。
+- 图 run 跑在 LangGraph runtime（独立于处理 HTTP 的 worker），刷新/换 worker 都能重新 join stream。
+- 数据卷：`.deer-flow/data/checkpoints.db` 必须挂出，否则容器重启丢状态。
+
+**验收**
+- `POST /start` 后立刻 `GET /{id}` 能拿到 `queued/running`；关掉 SSE 再重连能继续收进度。
+- 杀掉发起 start 的 worker（或多 worker 轮询），`resume`/`stream` 仍命中同一作业。
+- cleanup 干跑：活跃作业永不删，先删 CP 再删 DB。
+
+---
+
+## Phase 4 —— 前端：作业 API 客户端 + 数据模型扩展
+
+**目标**：前端有一层干净的作业 API 与类型，历史列表能拿到 status。
+
+**涉及文件（新增/改）**
+- 新增 `src/roundtable-planning/api/roundtable-jobs.ts`：
+  ```ts
+  export async function startJob(payload: StartJobPayload): Promise<RoundtableJob>
+  export async function getJob(id: string): Promise<RoundtableJob>
+  export function streamJob(id: string, on: (e: JobProgressEvent) => void): () => void  // 返回 unsubscribe
+  export async function resumeJob(id: string, answer: string): Promise<void>
+  export async function cancelJob(id: string): Promise<void>
+  ```
+  - `streamJob` 复用项目现有 SSE/`streamMultiAgent` 的封装方式（`api/multi-agent.ts:403+`），把
+    LangGraph `values` 映射成 §2.4 的归一化事件。
+- 改 `src/roundtable-planning/api/drafts.ts`：`DraftMeta` 增 `status?: JobStatus; jobId?: string`
+  （`drafts.ts:76-83` + 字段映射 `122-178` 加 snake_case 转换）。
+- 新增 `src/roundtable-planning/lib/job-types.ts`：把 §2.1–2.5 的类型集中导出。
+
+**验收**：`pnpm typecheck` 通过；`getJob`/`streamJob` 能拉到 Phase 3 的数据。
+
+---
+
+## Phase 5 —— 前端：Step2「后台挂起」按钮
+
+**目标**：Step2 顶栏/底栏加按钮，点击把当前任务交给后端后台跑，前端停止本地循环、转为观察者。
+
+**涉及文件（改）**
+- `src/roundtable-planning/components/Step2Panel.tsx`（按钮放在现有「进入第三步」附近 `370-381`）
+- `src/roundtable-planning/pages/RoundtablePlanningPage.tsx`（接线 + 观察者模式）
+- `src/roundtable-planning/hooks/useStep2Orchestration.ts`（暴露「停止本地循环并交后台」的方法）
+
+**步骤**
+1. Step2Panel 加「⏼ 后台挂起」按钮，`onBackgroundSuspend` 回调。
+2. 页面 `handleBackgroundSuspend`：
+   - `ensureDraft(2)` 拿到 `draftId`（`useDraftPersistence.ts` ensureDraft）。
+   - 收集当前状态：`intentReady`、`selectedAgents`、`threadIds`、`coordinatorName`、`model`、
+     `orchestrationMode`、`chain`（全部来自 `step2`/`step1` 现有状态）。
+   - `startJob(...)` → 拿到 `jobId`。
+   - **停止前端本地编排**：调用 `step2.stopOrchestration()` + 置一个 `backgroundedJobId` 标记，
+     让 `currentStep===2` 的 useEffect **不再自启本地循环**（在 `useStep2Orchestration.ts:1468-1541`
+     的启动条件里加 `&& !backgrounded`）。
+   - toast「已转入后台，可离开页面，任务会自动跑到结果绘制完成」。
+   - 刷新历史列表（`drafts` 重新拉，进行中项即出现 spinner）。
+3. **观察者模式**：若当前停留在 Step2 且该 draft 有 running 作业，订阅 `streamJob`，把进度事件渲染成
+   对话气泡/活动席位（复用现有 Step2 渲染），而不是本地驱动。
+
+**注意：避免「双跑」**——后台已接管后，前端绝不能再并行驱动同一批 thread。用 `backgroundedJobId`
+互斥；加载草稿时若发现有 running 作业，直接进观察者模式。
+
+**验收**：点「后台挂起」→ 可立即切到别的任务/路由；回来仍在跑；不会出现前后端同时派活。
+
+---
+
+## Phase 6 —— 前端：历史下拉框「进行中」加载动画
+
+**目标**：历史下拉里 `status==='running'`（或 `awaiting_input`）的草稿条目显示加载动画；点击进行中
+条目不直接 load，而是打开流程图弹窗。
+
+**涉及文件（改）**
+- `src/roundtable-planning/pages/RoundtablePlanningPage.tsx` 的 `HistoryDropdown`（`771-892`）
+
+**步骤**
+1. 列表项左侧名称前/后，按 `d.status` 渲染状态标记：
+   - `running` → 旋转的 `Loader2`（`animate-spin`）+「进行中」。
+   - `awaiting_input` → 呼吸点 +「待澄清」（琥珀色）。
+   - `done`/无 → 维持现状（显示 `Step {furthestStep}`）。
+   - `error` → 红点 +「出错」。
+2. 点击行为分流：
+   - `running`/`awaiting_input` → `openDispatchChainModal(d.jobId)`（Phase 7），**不**直接 `onLoad`。
+   - 其它 → 维持 `onLoad(id)`。
+3. 列表需要 `status`，确保 Phase 4 的 `DraftMeta.status` 已就位；下拉打开时 `refresh()` 拉最新。
+
+**验收**：后台挂起后，历史下拉对应条目转圈；点击弹出流程图弹窗。
+
+---
+
+## Phase 7 —— 前端：派活链路流程图弹窗（横向 / 大弹窗 / 动画）
+
+**目标**：大弹窗，横向排列的智能体派活链路。节点 = 席位（图标 + 名称），不同颜色；正在发言的
+节点和它的连接线带加载动画；含「查看」按钮。
+
+**涉及文件（新增）**
+- `src/roundtable-planning/components/DispatchChainModal.tsx`
+
+**实现选型**：链路是「总控 → 席位序列」的线性结构 + 需要对**单个节点和单条连线**做精确动画，
+**推荐手写 flex 横向布局 + CSS 动画连接线**（轻、可控）。项目已装 `@xyflow/react@12`（带 `animated`
+边）作为备选，但手写对本场景的「节点 loading + 连线流动」更直接。
+
+**结构（手写方案草图）**
+```tsx
+<Dialog open={open} onOpenChange={onOpenChange}>
+  <DialogContent className="flex max-h-[88vh] flex-col gap-0 sm:max-w-5xl"> {/* 大弹窗 */}
+    <DialogHeader>… 任务标题 + 阶段标签（leader_thinking/dispatching/report_drawing…） …</DialogHeader>
+
+    {/* 横向链路：总控 ──▶ 席位1 ──▶ 席位2 ──▶ … ──▶ [共识] ──▶ [报告绘制] */}
+    <div className="custom-scrollbar overflow-x-auto py-8">
+      <div className="flex items-center gap-0 min-w-max px-6">
+        <CoordinatorNode active={phase==='leader_thinking'} />
+        {nodes.map((n,i)=>(
+          <Fragment key={n.agentId}>
+            <Connector active={n.state==='active'} />            {/* 活动连线：流动虚线动画 */}
+            <ChainNode node={n} />                               {/* 活动节点：彩色+脉冲光环 */}
+          </Fragment>
+        ))}
+        <Connector active={phase==='consensus'} />
+        <MilestoneNode label="共识" done={consensus===100} />
+        <Connector active={phase==='report_drawing'} />
+        <MilestoneNode label="报告绘制" active={phase==='report_drawing'} done={phase==='report_done'} />
+      </div>
+    </div>
+
+    <DialogFooter className="border-t pt-3 sm:justify-between">
+      <span className="text-xs text-muted-foreground">轮次 {cycle}/8 · {statusLabel}</span>
+      <Button onClick={onView}>查看</Button>   {/* Phase 8 */}
+    </DialogFooter>
+  </DialogContent>
+</Dialog>
+```
+
+**节点颜色**：`avatarType = getAvatarTypeFor(agentId, order)` → `chainTagClasses(avatarType)`
+（复用 `lib/business-chain.ts:56-72` + `lib/roundtable-constants.ts`），与业务链条卡片同一套色。
+
+**节点状态样式**
+- `pending`：灰色描边、低透明度。
+- `active`：席位色填充 + 外圈 `animate-ping`/脉冲光环 + 图标旋转或呼吸。
+- `done`：席位色实心 + 右上角 ✓。
+
+**连接线加载动画（active 连线）**：CSS 流动虚线（marching-ants）或渐变扫光：
+```css
+/* roundtable-planning.css 追加 */
+@keyframes chain-flow { to { background-position: 20px 0; } }
+.chain-connector--active {
+  background-image: linear-gradient(90deg, var(--brand-500) 50%, transparent 50%);
+  background-size: 20px 100%;
+  animation: chain-flow 0.6s linear infinite;
+}
+```
+
+**数据来源**：弹窗 mount 时 `getJob(jobId)` 取首帧，随后 `streamJob(jobId, onEvent)` 实时更新
+`nodes`/`activeAgentId`/`phase`/`consensus`/`cycle`；`done` 事件后停止动画、全节点置 `done`。
+弹窗关闭时 `unsubscribe`。
+
+**验收**：弹窗够大、横向滚动；活动席位节点和它左侧连线在动；阶段推进时高亮顺移；`done` 后静止。
+
+---
+
+## Phase 8 —— 前端：「查看」进入进行中任务并实时观察
+
+**目标**：弹窗「查看」→ 进入该任务，停在 Step2 实时看后台进度（气泡/活动席位随 SSE 刷新），
+跑完自动呈现 Step3 结果。
+
+**涉及文件（改）**
+- `RoundtablePlanningPage.tsx`（接 `onView`）
+- `useDraftPersistence.ts`（`handleLoadDraft` 增「带作业」分支）
+- `useStep2Orchestration.ts`（观察者渲染）
+
+**步骤**
+1. `onView`：关弹窗 → `handleLoadDraft(draftId)` 恢复该草稿到 Step2（`useDraftPersistence.ts:308-368`），
+   但**跳过本地编排自启**（识别到有 running 作业 → 进观察者模式，对齐 Phase 5 的互斥标记）。
+2. 订阅 `streamJob(jobId)`，把 `dialogue` 事件 append 进 `step2RoundtableDialogues`、`active` 事件
+   驱动 `activeSpeakerId` 高亮、`consensus` 更新百分比。
+3. 命中 `awaiting_input`：在 Step2 弹出澄清输入（复用现有 `pendingClarification` UI），用户回答 →
+   `resumeJob(jobId, answer)`（而非本地 `submitClarification`）。
+4. `done` 事件：用返回的 `DraftStep3Snapshot` 走 `hydrateStep3` + 允许切到 Step3 查看报告
+   （`useStep3Report.hydrateSaved` `708-767`）；作业列表该项变「已完成」。
+
+**验收**：从历史「查看」进入能实时看到后台在跑；澄清能在前端回答并续跑；跑完能看到最终报告。
+
+---
+
+## Phase 9 —— 边界、健壮性与收尾
+
+1. **双跑互斥**：任一 draft 同一时刻只允许一个执行者（前端本地 or 后台作业）。加载草稿/进入 Step2
+   前先 `GET /api/roundtable-jobs?draftId=`，有 running 就进观察者模式。
+2. **后台命中澄清**：`awaiting_input` 时历史下拉显示「待澄清」徽标；流程图弹窗显示「等待澄清」；
+   只有「查看」进去才能回答（或在弹窗里直接给一个回答框，调用 `resumeJob`）。
+3. **取消**：流程图弹窗/Step2 提供「停止后台」→ `cancelJob`，`status→cancelled`，前端可恢复本地编辑。
+4. **错误恢复**：`error` 事件展示 detail；允许「重试」= 重新 `startJob`（沿用已建 threadIds）。
+5. **MAX_CYCLES / 预算**：后台图内兜底（对齐前端 `MAX_CYCLES=8`），到顶强制收敛并照常进 Step3。
+6. **多 worker**：严格遵守 Phase 3 的「状态进 DB+checkpointer、SSE 走 loopback」；部署若多 worker
+   需 sticky 或全靠 DB 态（推荐后者）。
+7. **清理**：`roundtable_jobs` cleanup cron（活跃保护、先删 CP 再删 DB），与 draft 生命周期对齐。
+8. **历史列表性能**：draft 列表 join 作业 status 时注意 N+1；用一次 LEFT JOIN 取最新作业。
+
+---
+
+## 端到端验证清单（提测前逐条过）
+
+- [ ] Step2 点「后台挂起」→ 立刻可离开页面 / 切到别的任务，后台继续跑。
+- [ ] 历史下拉里该任务显示加载动画（转圈）。
+- [ ] 点击进行中任务 → 大弹窗、横向派活链路、活动节点+连线在动、节点不同颜色。
+- [ ] 阶段推进（leader→派活→共识→报告绘制）时弹窗高亮顺移。
+- [ ] 弹窗「查看」→ 进入任务实时观察气泡/活动席位。
+- [ ] 后台命中澄清 → 列表「待澄清」+ 弹窗提示 + 可回答续跑（`resumeJob`）。
+- [ ] 一路自动跑到 Step3「绘制完成」，最终报告可在 Step3 查看，作业 `done`。
+- [ ] 浏览器刷新 / 关页重开后，任务仍在后台跑、状态可恢复（真后台验证）。
+- [ ] 取消后台 → `cancelled`，无残留双跑。
+- [ ] 多 worker（或杀 worker）下 stream/resume 不丢会话。
+- [ ] cleanup 干跑不误删活跃作业。
+
+---
+
+## 工作量与排期建议
+
+| 阶段 | 内容 | 粗估 | 依赖 |
+|------|------|------|------|
+| P0 | 数据契约定型（本文 §2） | 0.5d | — |
+| P1 | 后端作业表 + repo + 迁移 | 1d | P0 |
+| **P2** | **后端编排图（移植循环）** | **3–5d（核心难点）** | P0,P1 |
+| P3 | 后端控制 + SSE + cleanup | 1.5d | P1,P2 |
+| P4 | 前端作业 API + 类型 + draft status | 0.5d | P3 |
+| P5 | Step2 后台挂起按钮 + 互斥 | 1d | P4 |
+| P6 | 历史下拉 loading 动画 | 0.5d | P4 |
+| P7 | 派活链路流程图弹窗 | 1.5d | P4 |
+| P8 | 「查看」实时观察 + 澄清续跑 | 1.5d | P5,P7 |
+| P9 | 边界/健壮性/清理 | 1d | 全部 |
+
+> 建议先打通 **P1→P2→P3** 的后端最小闭环（脚本验证图能后台跑到出报告），再做前端 P4–P8。
+> P2 是整条链路成败的关键，务必先用脱离前端的探针脚本（仿 `scripts/probe_ai_writing_assistant.py`）跑通。
+
+---
+
+## 附：关键参考代码索引
+
+- 前端编排循环（待移植到后端）：`useStep2Orchestration.ts:992-1204,1228-1439,1468-1541`
+- 共识判定 / 进 Step3：`useStep2Orchestration.ts:1091-1099`、`Step2Panel.tsx:370-381`、`RoundtablePlanningPage.tsx:586-595`
+- Step3 绘制完成标志：`useStep3Report.ts:51,165,560-596,636-652`
+- 草稿模型 / API / 自动保存 / 加载恢复：`api/drafts.ts:25-110,184-225`、`useDraftPersistence.ts:248-316,308-368`
+- 历史下拉 UI：`RoundtablePlanningPage.tsx:771-892`
+- 后端单轮执行 / 派活 / 广播：`multi_agent.py:647-823,1076-1142,525-552,487-502`、loopback `271-293`
+- AI 写作模板：`agents/ai_writing/graph.py`、`ai_writing_sessions/model.py:14-39`、`ai_writing.py`、`ai_writing_cleanup.py:307-367`、`AIWritingPage.tsx` 文件头注释
+- 颜色体系复用：`lib/business-chain.ts:56-72`、`lib/roundtable-constants.ts`（`getAvatarTypeFor`）
+- 流程图备选库：`@xyflow/react@12`（已安装）
+```

frontend-web/docs/multi-agent-business-chain-dev.md

@@ -0,0 +1,400 @@
+# 业务链条模式 · 需求与分步实现文档
+
+> 面向「智能体推荐弹窗」的扩展：在现有**智能推荐**之外，新增**业务链条选择**与**业务链条配置**两块能力；选定业务链条后，Step 2 圆桌研讨**按链条内的固定顺序**逐个发言（而非现在的总控派活）。
+>
+> 配套阅读：
+> - 前端总览：`multi-agent-frontend-dev.md`（推荐弹窗 §6.2、Step 2 编排 §5.4、草稿持久化 §5.7）
+> - 后端总览：`multi-agent-backend-dev.md`（Step 2 §6、草稿/历史持久化 §7A）
+>
+> 本文档约定：**「席位 / 智能体」**指一个 agent；**「业务链条 / chain」**指一组有序排列的 agent 配置，是可命名、可复用、可持久化的实体。
+
+---
+
+## 0. 需求原文拆解
+
+用户原始诉求逐条拆成可实现条目：
+
+| # | 原始诉求 | 拆解 |
+|---|----------|------|
+| 1 | 推荐弹窗要有「模式选择」 | 弹窗顶部加模式切换（智能推荐 / 业务链条），两种模式互斥，确认后都产出**有序**的 `SelectedAgent[]` |
+| 2 | 「智能推荐」就是现在这个 | 现有 `RecommendAgentsDialog` 整体收进「智能推荐」模式，行为不变 |
+| 3 | 「业务链条选择」是卡片列表 | 卡片 = 标题 + 一排智能体名 tag；tag 不同颜色；tag 之间有**向左箭头**连接，表达链条次序 |
+| 4 | 业务链条需要一个**配置页面** | 左侧智能体列表（复用 `GET /api/agents`），右侧有序长条卡片（名称 + 描述）；支持右侧内部拖拽排序、左→右拖入指定位置 |
+| 5 | 配置页用弹窗还是新页面？ | **本文档决策：独立路由页面**（理由见 §2.1） |
+| 6 | 选定链条后，Step 2 用链条内智能体研讨 | 复用既有 Step 2 init/stream；**总控（leader）按链条顺序逐个派活**（§6） |
+| 7 | 规划成分步可实现的需求文档 | 见 §7 分阶段实现 |
+
+---
+
+## 1. 目标与非目标
+
+### 1.1 目标
+- 推荐弹窗成为「**席位来源选择器**」：无论智能推荐还是业务链条，最终都向 `onConfirm` 交付一个**有序的 `{ agent_id, name }[]`** + 一个 `orchestrationMode`。
+- 业务链条是**用户可创建、命名、保存、复用、删除**的有序智能体编排模板。
+- Step 2 支持两种编排：
+  - `recommend` 模式 → 现有总控**自由派活**循环（不动）。
+  - `chain` 模式 → 总控仍是派活方，但**被约束按链条顺序逐个派活**（新增）。
+
+### 1.2 非目标（本期不做，留扩展点）
+- 链条内每个席位的 per-seat prompt/temperature 真实覆盖（仍仅前端记录，沿用现状）。
+- 链条的分支 / 条件流转（只做线性顺序链）。
+- 链条跨用户共享 / 市场（先做「本人私有链条」）。
+- 链条版本管理 / 协作编辑。
+
+---
+
+## 2. 关键设计决策
+
+### 2.1 决策 A：配置页面用「独立路由页面」而非弹窗 ✅
+
+**结论：业务链条的「编辑/管理」用独立路由页面 `/page/workspace/roundtable/chains`；业务链条的「选择」仍内嵌在推荐弹窗里（卡片列表）。**
+
+理由：
+
+| 维度 | 弹窗 | 独立页面 ✅ |
+|------|------|------------|
+| 双栏 + 拖拽 + 长条卡片 | 弹窗宽度（`sm:max-w-3xl`）+ `max-h-[85vh]` 拖拽空间局促，左右栏挤 | 整屏宽度，拖拽手感好 |
+| 复用入口 | 只能从推荐弹窗进 | 可从侧栏、推荐弹窗「管理链条」按钮、深链接进入 |
+| 可深链接/刷新 | 不可 | `/roundtable/chains` 可直达、可分享 |
+| 推荐弹窗内嵌编辑器 | 弹窗套弹窗 / 模式套编辑，状态复杂 | 关注点分离：弹窗只「选」，页面只「编」 |
+
+**分工**：
+- **推荐弹窗**：模式选择 + 业务链条**选择**（只读卡片列表，可点「去配置」跳到页面）。
+- **配置页面**：业务链条的**增删改**（双栏拖拽编辑器 + 链条列表管理）。
+
+> 备选：若产品坚持不加路由，可改为**全屏 Dialog（`max-w-[90vw] h-[90vh]`）**承载编辑器，从推荐弹窗内打开。结构与页面版一致，仅外壳不同。本文档按「独立页面」实现，§7 标注了切换成本。
+
+### 2.2 决策 B：链条持久化 —— 后端 MySQL（确定） ✅
+
+**结论：业务链条存后端 MySQL，仿 `roundtable_drafts`（§7A）新建 `roundtable_chains` 表 + `/api/roundtable-chains` 路由，按登录用户隔离、跨设备保留。** 不走 localStorage。
+
+理由：链条是可复用、需跨设备/会话保留的模板，与草稿/推荐历史性质一致；草稿当年正是因 localStorage 换设备即丢才迁后端（§7A），链条不重复踩坑。
+
+落地：
+- 表/路由设计见 §5.2，是「复制 §7A 草稿持久化、把字段换成 chain」的机械工作。
+- 前端 `api/chains.ts` 直接打后端接口（snake_case↔camelCase 在这层收口，仿 `api/drafts.ts`），**不提供 localStorage 实现**。
+- 后端表必须先于前端 UI 落地（§7 阶段 0 即包含后端表/路由）。
+
+### 2.3 决策 C：拖拽库选型 —— `@dnd-kit`
+
+仓库**当前无任何拖拽库**（`package.json` 无 `@dnd-kit` / `react-dnd` / `sortablejs`；`@xyflow/react` 是节点图，不适合列表排序）。
+
+| 方案 | 取舍 |
+|------|------|
+| **`@dnd-kit/core` + `@dnd-kit/sortable`**（推荐） | React 19 友好、可访问性好、跨容器拖入 + 列表排序 + 插入指示器开箱即用；新增 ~30KB gzip 依赖 |
+| 原生 HTML5 DnD（零依赖兜底） | 不加依赖，但跨容器插入位置指示、键盘可达性都要手写，易出 bug |
+
+**建议**：新增 `@dnd-kit/core`、`@dnd-kit/sortable`、`@dnd-kit/utilities`。若产品方禁止新增依赖，退回原生 HTML5 DnD（§7 阶段 2 标注差异）。
+
+### 2.4 决策 D：Step 2「总控按链条顺序派活」，后端零改动 ✅
+
+**形态：总控（leader）仍是唯一派活方，但每一轮被前端约束「只能派给链条里的下一个席位」，逐个走完整条链，最后由总控收口。** 区别于 recommend 模式的「总控自由决定派给谁」。
+
+为什么后端无需改动：
+- Step 2 后端 `streamMultiAgent({ agentType: "leader" })` 每轮返回 `dispatched = [[agent, task], ...]`；`agentType: "special"` 单独驱动某席位跑一轮。这两个原语已足够。
+- 每个 special 跑完，后端 `_broadcast` 会把「子智能体 X 完成…交付内容为:…」append 进**其它所有席位 + 总控 thread** 的历史（后端 §6.4），所以链路上下文天然累积。
+- chain 模式只是**改变前端怎么提示 leader、以及怎么校验它的派活**——把每轮 leader 的提示词约束成「请向链条第 i 位【X】派活」，并对返回的 `dispatched` 做「必须命中链条下一席位」的校验/纠偏。**后端路由、SOUL、表结构都不动。**
+
+→ chain 模式 = 在 `useStep2Orchestration` 里新增 `runChainOrchestration`：按链条游标逐位调 leader（约束派给该位）→ 拿到 task → 调 special → 下一位 → 链尾后调一次 leader 收口。详见 §6。
+
+> 与「前端绕过 leader 直接顺序 special」的区别：本方案**保留总控在每一步的协调/串接职责**（leader 结合前序进展为下一席位编写针对性任务、并在派活说明里承上启下），更符合「总控按链条顺序派活」的语义，圆桌可视化里总控气泡也照常出现。
+
+---
+
+## 3. 数据模型与类型
+
+新增前端类型，建议放 `frontend-web/src/roundtable-planning/lib/business-chain.ts`：
+
+```ts
+/** 业务链条里的一个有序席位。 */
+export interface ChainSeat {
+  agent_id: string;
+  /** 落库时的快照名/描述，避免 agent 改名后链条显示错乱；展示优先用实时 agent 数据，回退到快照。 */
+  name: string;
+  description?: string;
+}
+
+/** 一条可复用的业务链条。 */
+export interface BusinessChain {
+  id: string;
+  title: string;
+  description?: string;
+  /** 有序席位列表；seats[0] 是第一个发言者。 */
+  seats: ChainSeat[];
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+/** 推荐弹窗确认后回传给主页面的统一结果。 */
+export interface SeatSelectionResult {
+  /** 有序席位（与现有 handleConfirmAgents 入参兼容）。 */
+  agents: Array<{ agent_id: string; name: string }>;
+  /** 决定 Step 2 走哪种编排。 */
+  mode: "recommend" | "chain";
+  /** chain 模式下带上来源链条（用于草稿快照 / Step 2 展示链名）。 */
+  chain?: Pick<BusinessChain, "id" | "title">;
+}
+```
+
+**约束**：链条席位数沿用圆桌的 `2 ≤ N ≤ 8`（`MIN_SELECTED`/`MAX_SELECTED`），配置页保存时校验。
+
+**tag 配色**：复用 `roundtable-constants.ts::getAvatarTypeFor(agentId, index)`，得到 `blue|purple|emerald|amber|pink|human`，再映射到已有的 avatar 配色 token（与圆桌可视化、Step 2 气泡同一套色板，视觉统一）。
+
+---
+
+## 4. 现有代码改动点速查
+
+| 位置 | 改动 | 说明 |
+|------|------|------|
+| `components/RecommendAgentsDialog.tsx` | 包一层「模式选择」外壳，现有内容收进「智能推荐」Tab | `onConfirm` 签名从 `agents[]` 升级为 `SeatSelectionResult`（或加可选第二参 `mode`，见 §7 阶段 3 的兼容策略） |
+| `pages/RoundtablePlanningPage.tsx` | `handleConfirmAgents` 接收 `mode`，存到新状态 `orchestrationMode` | 透传给 `useStep2Orchestration` |
+| `hooks/useStep2Orchestration.ts` | 新增 `runChainOrchestration` + `orchestrationMode` 分支 | init effect 里按 mode 选择 `runOrchestration` 或 `runChainOrchestration` |
+| `lib/roundtable-constants.ts` | 复用 `getAvatarTypeFor` / `SelectedAgent` | 不改，仅引用 |
+| `hooks/useDraftPersistence.ts` + `api/drafts.ts` | Step2 快照新增 `orchestrationMode` + `chain` 字段 | 草稿能记住「这次是链条模式」 |
+| `pages/WorkspaceRoutes.tsx` | 注册 `roundtable/chains` 路由 | 仿 `roundtable/planning` |
+| `components/page-sidebar.tsx`（如有侧栏入口） | 加「业务链条」入口（可选） | 也可只从推荐弹窗进 |
+| `api/chains.ts`（新增） | 链条 CRUD 客户端 | 直接打后端 `/api/roundtable-chains` |
+| 后端 `roundtable_chains` | 表 + 路由（MySQL） | 仿 `roundtable_drafts`，**必做** |
+
+---
+
+## 5. 链条持久化 API 设计
+
+### 5.1 前端客户端 `api/chains.ts`（直接打后端）
+
+```ts
+listChains(): Promise<BusinessChain[]>          // 当前用户全部链条
+getChain(id: string): Promise<BusinessChain>
+createChain(input: Omit<BusinessChain,"id"|"createdAt"|"updatedAt">): Promise<BusinessChain>
+updateChain(id: string, patch: Partial<BusinessChain>): Promise<BusinessChain>
+deleteChain(id: string): Promise<void>
+```
+
+- 实现用 `apiFetch` 打 `/api/roundtable-chains`（§5.2），snake_case↔camelCase 在这层收口（仿 `api/drafts.ts`）。
+- 不提供 localStorage 实现；后端表是前端 UI 的硬依赖。
+
+### 5.2 后端表 + 路由（仿 §7A `roundtable_drafts`）
+
+- 表 `roundtable_chains`：`id`(PK) / `user_id`(idx) / `title`(512) / `description`(text) / `seats`(`PortableLongText`，存 `ChainSeat[]` JSON) / `created_at` / `updated_at`(`BeijingDateTime`)。
+- 路由 `app/gateway/routers/roundtable_chains.py`，前缀 `/api/roundtable-chains`：`GET ``（列表）/ `POST ``（建）/ `GET /{id}` / `PUT /{id}`（partial，`exclude_unset`）/ `DELETE /{id}`。
+- 鉴权/属主：`_current_user_id(request)`，跨用户访问一律 404，与 `roundtable_drafts` 完全一致。
+- 启动 `Base.metadata.create_all` 自动建表（MySQL 生产 / sqlite 本地走同一套 SQLAlchemy 代码，`PortableLongText` 各自降级），登记进 `persistence/models/__init__.py`，store 接到 `app.state` 并 `include_router`。
+
+> 整体是「复制 §7A 的草稿持久化、把字段换成 chain」的机械工作，风险低。
+
+---
+
+## 6. Step 2 链条模式编排设计（`runChainOrchestration`）
+
+### 6.1 与现有 `runOrchestration` 的差异
+
+| 维度 | `runOrchestration`（recommend） | `runChainOrchestration`（chain，新增） |
+|------|--------------------------------|----------------------------------------|
+| 谁派活 | 总控 leader | 总控 leader（**不变**） |
+| 派给谁由谁定 | leader 自由决定 | 前端按链条游标**约束 leader 只能派给下一席位** |
+| 发言顺序 | leader 每轮自由派 | **链条数组的固定顺序** |
+| 循环结构 | `while` 直到 leader 返回 `[]` 共识 / MAX_CYCLES | 按链条游标走一趟（每位：leader 派活 → special 交付） |
+| 收口 | leader 返回 `[]` 即共识 | 链尾后再调一次 leader 做总结收口，产出 `lastLeaderContent` + `hasConsensus` |
+
+> **核心**：leader 始终在场，只是**每轮的派活目标被前端钉死成链条的下一席位**——前端在 leader 的 `newMessage` 里写明「本轮请通过 `agent_orchestration` 仅向【X】派活」，并对 `leaderRes.dispatched` 做命中校验/纠偏。
+
+### 6.2 伪代码
+
+```
+runChainOrchestration(seedMessage, ids, coord, chainSeats):
+  isOrchestrating = true
+  cancel = false
+  N = chainSeats.length
+
+  for (let i = 0; i < N; i++):           // 链条游标，逐位推进
+    if cancel: break
+    seat = chainSeats[i]
+    seatMeta = agentNameToRole[seat.agent_id]
+
+    // ── (a) 总控派活给「链条下一席位」──────────────────────────
+    highlightSpeaker(null)               // leader 阶段不高亮任何 sub
+    leaderBubble = appendStreamingDialogue("总控协调", confidence:"链条派活中")
+    leaderTask = buildChainLeaderTask({
+      seedMessage,                       // 任务目标/约束（首轮）
+      position: i, total: N,
+      nextSeat: seat,                    // 「本轮请仅向【X(seat.agent_id)】派活」
+      isFirst: i === 0,
+    })
+    leaderRes = await streamMultiAgent(leader, ids, coord, leaderTask, model=globalModel)
+
+    // 约束/纠偏：取 dispatched 中命中 seat.agent_id 的那条 task；
+    // 若 leader 没派或派错（派给非 seat、或派给多个），前端兜底：
+    //   - 命中就用它给出的 task 文本（保留总控的承上启下措辞）；
+    //   - 没命中则用 leader 的正文 content 作为兜底 task，或回退到模板 task。
+    task = pickChainTask(leaderRes, seat) 
+    // leader 若返回 clarification → 暂停链条，走与现状一致的澄清条（§6.3）
+    finalizeDialogue(leaderBubble, leaderRes.content, "派活说明")
+
+    // ── (b) 被派席位交付（special，顺序、不并行）──────────────────
+    markSpeakerStreaming(seatMeta.speakerId)
+    seatBubble = appendStreamingDialogue(seatMeta.displayName, confidence:"调度中")
+    perSeatModel = agentConfigs[seatMeta.speakerId]?.model || globalModel
+    specRes = await streamMultiAgent(special, ids, seat.agent_id, task, model=perSeatModel)
+    finalizeDialogue(seatBubble, specRes.content, "子智能体交付")
+    markSpeakerIdle(seatMeta.speakerId)
+    // 后端 _broadcast 已把本席位交付注入其余 thread 历史 → 下一席位天然可见
+
+  if cancel: return
+
+  // ── (c) 总控收口：综合全链交付，产出最终结论 ──────────────────
+  leaderBubble = appendStreamingDialogue("总控协调", confidence:"汇总链条结论")
+  leaderRes = await streamMultiAgent(leader, ids, coord,
+                "各链条席位已按顺序完成发言，请综合所有交付，输出最终方案，不要再派活。")
+  finalizeDialogue(leaderBubble, leaderRes.content, "全案盖印")
+  setLastLeaderContent(leaderRes.content)
+  setHasConsensus(true); setConsensusPercentage(100)
+  isOrchestrating = false
+```
+
+要点：
+- **派活方仍是总控**，符合「总控按链条顺序派活」的语义；圆桌可视化里每位席位前都先出现一个总控派活气泡，再出现该席位交付气泡。
+- **约束手段是 prompt + 前端校验，不动后端**：`buildChainLeaderTask` 把「本轮只能派给【X】」写进 leader 的 `newMessage`；`pickChainTask` 对 `leaderRes.dispatched` 做命中校验，派错/未派时兜底，保证链条游标严格推进。
+- **复用现有三段式气泡 / 高亮 / abort 基建**（`appendStreamingDialogue` / `finalizeDialogue` / `markSpeakerStreaming` / `activeAbortersRef` / `orchestrationCancelRef`），只是驱动顺序不同。
+- **special 仍是顺序**（不并行），与现状不变量一致（文件顶部注释 §1）。
+- **收口 leader 调用默认开**（产出 Step 3 结论）；若链条末位本身是「总结陈述」类，可关掉收口，直接拿末位交付当 `lastLeaderContent`。配置位 `chainNeedsLeaderSummary`（默认 true）。
+
+### 6.3 澄清 / 挂起 / 恢复 / 干预
+- **澄清**：链条中途某轮 leader 返回 `clarification` → 与现状一致，暂停链条、底部弹澄清条；用户回答后从**当前游标**继续（需记录 `chainCursor`）。
+- **挂起/恢复**：`isRoundTableRunning` toggle 复用现有机制；恢复时从 `chainCursor` 续跑。MVP 若不做断点续跑，可先只支持「整体停止 / 从头重跑」，UI 文案说明（扩展点，§7 阶段 4 标注）。
+- **干预**：可在两席位之间插入一条用户指令，由下一轮 leader 派活前消化。MVP 同上可后置。
+
+### 6.4 多轮链条（扩展点，非 MVP）
+单趟遍历是 MVP。若要「链条跑完后总控判断是否再来一轮」，可在收口 leader 处复用 `dispatched===[]?` 判定：收口 leader 若仍派活则回到链条头再跑一轮，直到共识或 MAX_CYCLES。MVP 不做，避免复杂度。
+
+### 6.5 init 复用
+chain 模式的 Step 2 init **完全复用** `initMultiAgent`：`agentNames = chainSeats.map(s => s.agent_id)`（**按链条顺序**传入，使 `buildRoleTemplates` 的 seat id 顺序 = 链条顺序，且后端注入 coordinator 的「可调度席位清单」也按此序）。init effect 里按 `orchestrationMode` 决定 init 完成后调 `runOrchestration` 还是 `runChainOrchestration`。
+
+---
+
+## 7. 分阶段实现计划
+
+> 每阶段都可独立交付、独立验收。建议顺序：**数据层 → 配置页 → 弹窗模式 → 链条选择 → Step2 编排 → 持久化兼容与收尾**。
+
+### 阶段 0 · 后端链条表 + 脚手架（1.5 天） ✅ 已完成
+**目标**：打地基（含后端持久化），不含前端 UI。
+- [x] **后端**：仿 §7A `roundtable_drafts` 新建 `roundtable_chains` 表 + `/api/roundtable-chains` 路由（§5.2）：
+  - [x] `persistence/roundtable_chains/`（model + sql repo + `make_roundtable_chain_store`），登记进 `persistence/models/__init__.py`。
+  - [x] `app/gateway/routers/roundtable_chains.py`（GET 列表 / POST / GET{id} / PUT{id} / DELETE），鉴权属主同 `roundtable_drafts`；席位 2–8 + 去重校验。
+  - [x] `deps.py` 接 `app.state.roundtable_chain_store`，`app.py` `include_router`。
+  - [x] 后端测试 `tests/test_roundtable_chains.py`：CRUD + 部分更新 + 跨用户隔离（5 用例全过）。
+- [x] **前端**：新增 `lib/business-chain.ts`（`ChainSeat` / `BusinessChain` / `SeatSelectionResult`，§3）+ `api/chains.ts`（直接打后端，§5.1）。
+- [x] （决策 C）安装 `@dnd-kit/core` `@dnd-kit/sortable` `@dnd-kit/utilities`。
+- **验收**：✅ 后端 5 用例通过；✅ 表注册进 `Base.metadata`、路由 `/api/roundtable-chains` 加载正常；✅ ruff 0 错；✅ 前端 typecheck 新增文件 0 错。
+
+### 阶段 1 · 业务链条配置页面（2–3 天） ✅ 已完成
+**目标**：能创建/编辑/保存/删除链条。
+- [x] 路由：`WorkspaceRoutes.tsx` 注册 `roundtable/chains`（套 `WorkspaceLayout`；本页**不需要** `ChatRuntime`，无沙箱依赖）。
+- [x] 页面 `roundtable-planning/pages/BusinessChainEditorPage.tsx`：
+  - [x] 顶部：链条列表下拉（`<select>` 列出已存链条 + 新建项）/ 新建按钮 / 标题+描述输入 / 保存 / 删除（`window.confirm`）。
+  - [x] **左栏**：候选智能体（`listAgents()` + `filterRecommendCandidates`），竖排卡片，可拖、可点「＋」快捷加入；已加入的置灰「已加入」。
+  - [x] **右栏**：有序长条卡片（序号 tag + 名称 + 描述 + 移除），`SortableContext` 内拖拽排序；空态有占位提示。
+  - [x] 拖拽用 `@dnd-kit`：左栏 `useDraggable`，右栏 `useDroppable` + `SortableContext`/`useSortable`，`onDragEnd` 计算插入 index（pool→右栏按落点插入；seat→seat `arrayMove`）；`DragOverlay` 跟手卡片。
+  - [x] 校验：`2 ≤ seats ≤ 8`（前端禁用保存 + toast，后端 `_validate_seats` 兜底），重复 agent 去重提示。
+- [x] 保存走 `api/chains.ts`（create 用 `nanoid()` 客户端 id，update 走同一 id）。
+- **验收**：✅ typecheck 0 新增错误（76 个预存量错误均在无关模块）。**人工验收待跑**：新建「情报→方案→风险→总结」链保存 → 刷新后下拉重载 → 右栏拖拽排序 → 左栏拖入指定位 → 2–8 边界禁用保存。
+- **切换成本备注**：若改全屏 Dialog 方案，编辑器组件原样复用，仅去掉路由、外面套 `Dialog`。
+- **入口说明**：圆桌本身未在侧栏（`sidebar-menu.ts` 入口被注释），本页暂经直链 `/page/workspace/roundtable/chains` 或顶栏「返回圆桌」往返；阶段 3 推荐弹窗「去配置」按钮会导航到此。
+- **视觉（后续重画）**：本页**不**套圆桌 `roundtable-planning` scope，直接遵循《浅红色/深蓝色 UI 规范》——用 app 语义 token（光 `--primary` 红 hue27 / 暗 蓝 hue259，已内置自适应）+ 规范小圆角（输入/按钮/tag/卡片内项 2px = `R_CTRL`，分栏/面板 4px = `R_CARD`）+ 克制阴影（`PANEL_SHADOW`）。筛选框复用通用 `TagSearchBar`，配色随 app 中性 token，不再被红 scope 染色。
+
+### 阶段 2 · 推荐弹窗「模式选择」外壳（1 天） ✅ 已完成
+**目标**：弹窗顶部模式切换，智能推荐行为不变。
+- [x] `RecommendAgentsDialog` 顶部加**分段按钮**模式切换：`智能推荐 | 业务链条`（active 态品牌色 + 卡底；DialogDescription 随模式切换文案）。
+- [x] 现有全部内容原样收进「智能推荐」面板（`{mode === "recommend" && (<>…</>)}` 包裹，**零行为变更**）。
+- [x] 「业务链条」面板放占位：居中提示 + 「去配置业务链条」按钮（`handleGoConfig` → 关弹窗 + 跳 `roundtable/chains`）。
+- [x] `onConfirm` 统一升级为回传 `SeatSelectionResult`（含 `mode`）：智能推荐确认回传 `{ agents, mode: "recommend" }`；主页面 `handleConfirmAgents` 同步改签名取 `result.agents`（`result.mode` 预留给阶段 4）。
+- **验收**：✅ typecheck 0 新增错误（总数仍 76）；智能推荐分支 JSX/逻辑原样保留（流式/勾选/进入研讨未改）；模式切换只切显示、`state`/`selectedIds` 不卸载 → 候选池不丢。**人工验收待跑**：切到业务链条→再切回，推荐结果与勾选仍在。
+
+### 阶段 3 · 业务链条选择卡片列表（1.5 天） ✅ 已完成
+**目标**：弹窗「业务链条」面板里选链条。新增 `components/BusinessChainPicker.tsx`，替换阶段 2 的占位。
+- [x] 进入该 Tab 时 `listChains()` 拉本人链条 + `listAgents()` 取存活 id/名称，渲染**卡片列表**：
+  - [x] 卡片标题（链条 title）+ 「N 席」徽章 + 选中 ✓；描述行。
+  - [x] 标题下一排**智能体名 tag**：按链条顺序**从左到右**、不同颜色（`getAvatarTypeFor`→`chainTagClasses`），tag 之间插 `→`（`ArrowRightIcon`）箭头连接（`seats[0]` 最左、先发言）。
+  - [x] 底部「配置链条」按钮（跳 `roundtable/chains`）。
+- [x] 空态：无链条时引导「去配置页面创建第一条业务链条」+ 按钮。
+- [x] 选中一条 → 高亮（`ring-primary`）；底部「进入研讨」`onConfirm({ agents: 存活席位有序, mode:"chain", chain:{id,title} })`。
+- [x] 链条里有 agent 已不存在（被删）→ 该 tag 置灰删除线 + `title` 提示 + 卡片下方 amber 警告；confirm 按**存活席位**过滤；存活 < `CHAIN_MIN_SEATS` 则禁用「进入研讨」并提示。agent 列表加载失败时 `existingIds=null` → 不误判删除。
+- **验收**：✅ typecheck 0 新增错误（总数仍 76）。卡片渲染标题 + 彩色 tag + ← 箭头；选链 → `onConfirm(mode:"chain")` → `handleConfirmAgents` 按链条顺序 `setSelectedAgents` → Step 2 左侧「参与角色」顺序 = 链条顺序（**按顺序派活在阶段 4**）。**人工 UI 验收待跑**。
+- **箭头方向**（已确认）：tag 左→右排列、`→`（`ArrowRightIcon`）连接，`seats[0]` 最左、先发言，箭头顺读即链条研讨顺序。
+
+### 阶段 4 · Step 2 链条顺序编排（2–3 天） ✅ 已完成
+**目标**：chain 模式按链顺序逐席发言。**后端零改动。**
+- [x] 主页面新增 `orchestrationMode` 状态，`handleConfirmAgents` 从 `SeatSelectionResult.mode` 写入（chain 模式 toast 带链名）；`handleStartNewTask` 复位为 `recommend`；透传给 `useStep2Orchestration`。chain 顺序 = `selectedAgents`（确认时已按链条顺序写入），无需单独 `chainSeats`。
+- [x] `useStep2Orchestration` 新增 `runChainOrchestration`（§6.2）+ `orchestrationModeRef`/`selectedAgentsRef`；复用现有三段式气泡/高亮/abort 基建。
+- [x] 新增 `runActiveOrchestration` 分发器：init / 恢复 / 干预 / 澄清回复 4 处调用点统一改走它，按 `orchestrationModeRef` 选 `runOrchestration`（recommend）或 `runChainOrchestration`（chain）。
+- [x] `runChainOrchestration`：按 `selectedAgents` 游标，每位先 leader 约束派活（`buildChainLeaderTask` 钉死目标席位 + `pickChainTask` 命中校验/纠偏，派错/未派都兜底推进）→ 再对**该席位**跑 special；中途 leader 若 `clarification` 则暂停（MVP 回复后整链重跑）。
+- [x] `initMultiAgent` 的 `agentNames` 即 `roundtableAgentIds`（由 `selectedAgents` 派生，已是链条顺序，§6.5）。
+- [x] 收口 leader（`finishedAllSeats` 时触发），产出 `lastLeaderContent` + `hasConsensus=true` + `consensusPercentage=100` 解锁 Step 3。
+- **验收**：✅ typecheck 0 新增错误（总数仍 76）；✅ 唯一直接引用 `runOrchestration` 的是 dispatcher。逻辑层：每席「总控派活气泡 → 席位交付气泡」、严格顺序、单 special 在跑、`_broadcast` 注入前序上下文、leader 纠偏推进、跑完解锁 Step 3、abort 可中断。**人工 UI 验收待跑**。
+- **MVP 边界**：chain 模式的「挂起→断点续跑」「逐席间干预」未做断点续跑，`clarification`/恢复/干预当前为**整链重跑**（`chainCursor` 列为扩展点）。
+
+### 阶段 5 · 草稿持久化兼容 + 收尾（1 天） ✅ 已完成
+**目标**：草稿记住模式，回归不破。
+- [x] `Step2Snapshot`（`useStep2Orchestration.ts`）+ `DraftStep2Snapshot`（`api/drafts.ts`）新增 `orchestrationMode?: "recommend"|"chain"` 与 `chain?: {id,title}|null`。
+- [x] 恢复路径：`orchestrationMode`/`chainMeta` 是**主页面 state**，`getStep2Snapshot` 写入；**包裹版 `hydrateStep2`** 在加载时 `setOrchestrationMode(snapshot.orchestrationMode ?? "recommend")` + `setChainMeta(snapshot.chain ?? null)` 再调 `step2.hydrateFromDraft`；老草稿无字段 → 默认 `recommend`（向后兼容）。`handleStartNewTask` 复位两者。
+- [x] 文档回写：`multi-agent-frontend-dev.md` §5.7（快照形状 + `orchestrationMode/chain` 说明）、§6.2（席位来源选择器导语）；`multi-agent-backend-dev.md` 新增 §7B（`roundtable_chains` 表/路由）。
+- **验收**：✅ `pnpm typecheck` 0 新增错误（总数仍 76）。逻辑：chain 会话保存草稿 → 重载 `orchestrationMode="chain"` + 链信息恢复；老草稿（无字段）默认 recommend 照常加载。**人工 UI 验收 + `pnpm build` 待跑**。
+
+### 工期粗估
+| 阶段 | 估时 |
+|------|------|
+| 0 后端链条表 + 脚手架 | 1.5d |
+| 1 配置页 | 2–3d |
+| 2 弹窗模式壳 | 1d |
+| 3 链条选择卡片 | 1.5d |
+| 4 Step2 链编排 | 2–3d |
+| 5 持久化兼容收尾 | 1d |
+| **合计** | **约 9–11 人日**（含后端 `roundtable_chains` 表/路由） |
+
+---
+
+## 8. 验收清单（端到端）
+
+1. 推荐弹窗顶部有「智能推荐 / 业务链条」切换；智能推荐与现状逐像素一致。
+2. 配置页 `/page/workspace/roundtable/chains` 左栏列出智能体、右栏有序长条卡片；左→右拖入指定位、右栏内拖拽排序均生效；2–8 校验生效；保存/重载/删除正常。
+3. 业务链条卡片：标题 + 彩色智能体 tag + ← 箭头连接，渲染正确。
+4. 选定链条 → Step 2 席位顺序 = 链条顺序，并**按顺序逐个发言**，后序能看到前序交付。
+5. chain 跑完解锁 Step 3；草稿记住 chain 模式并可重载。
+6. 删除链条中引用的 agent 后，选择端有降级提示，不崩。
+
+---
+
+## 9. 风险与开放问题
+
+| # | 项 | 说明 / 建议 |
+|---|----|-------------|
+| 1 | 配置页：弹窗 vs 页面 | 本文档定为**独立页面**（§2.1）。若产品要弹窗，编辑器组件可复用，仅换外壳。**请确认。** |
+| 2 | 链条持久化 | **已定：后端 MySQL `roundtable_chains`**（§2.2 / §5.2），仿草稿持久化。 |
+| 3 | Step 2 链编排 | **已定：总控按链条顺序派活**（§2.4 / §6），后端零改动。 |
+| 4 | 新增 `@dnd-kit` 依赖 | 若禁止新增依赖，退原生 HTML5 DnD（手感与可达性下降）。**请确认。** |
+| 5 | ← 箭头方向 / tag 阅读顺序 | 默认 `seats[0]` 在最左、先发言；箭头仅作视觉连接。**请确认是否要「从右往左读」。** |
+| 6 | chain 模式是否需要收口 leader 总结 | 默认需要（产出 Step 3 结论）。若末位席位自带总结可关掉。 |
+| 7 | leader 派活纠偏策略 | leader 派错/未派时前端兜底推进游标（§6.2 `pickChainTask`）；可加 toast 提示「已按链条强制推进」。 |
+| 8 | chain 模式断点续跑 / 逐席干预 | MVP 不做，列为扩展点（§6.3 / §7 阶段 4）。 |
+| 9 | 链条是否私有 | 本期仅本人私有（仿草稿按 `user_id` 隔离）。共享/市场留扩展。 |
+
+---
+
+## 10. 路径速查（新增/改动）
+
+| 资源 | 路径 | 状态 |
+|------|------|------|
+| 链条类型 | `frontend-web/src/roundtable-planning/lib/business-chain.ts` | 新增 |
+| 链条 API 客户端 | `frontend-web/src/roundtable-planning/api/chains.ts` | 新增 |
+| 配置页 | `frontend-web/src/roundtable-planning/pages/BusinessChainEditorPage.tsx` | 新增 |
+| 链条选择面板 | `frontend-web/src/roundtable-planning/components/BusinessChainPicker.tsx` | 新增 |
+| 链条卡片 | `frontend-web/src/roundtable-planning/components/BusinessChainCard.tsx` | 新增 |
+| 推荐弹窗（加模式壳） | `frontend-web/src/roundtable-planning/components/RecommendAgentsDialog.tsx` | 改 |
+| 主页面（mode 透传） | `frontend-web/src/roundtable-planning/pages/RoundtablePlanningPage.tsx` | 改 |
+| Step2 编排（加 chain） | `frontend-web/src/roundtable-planning/hooks/useStep2Orchestration.ts` | 改 |
+| 草稿快照（加 mode） | `hooks/useDraftPersistence.ts` + `api/drafts.ts` | 改 |
+| 路由注册 | `frontend-web/src/pages/WorkspaceRoutes.tsx` | 改 |
+| 后端链条持久化 | `offline-backend-20260512/backend/packages/harness/deerflow/persistence/roundtable_chains/` | 新增 |
+| 后端链条路由 | `offline-backend-20260512/backend/app/gateway/routers/roundtable_chains.py` | 新增 |
+| 后端 store 接线 | `offline-backend-20260512/backend/app/gateway/deps.py`（`app.state.roundtable_chain_store`）+ `app.py` | 改 |
+</content>
+</invoke>

frontend-web/docs/multi-agent-frontend-dev.md

@@ -0,0 +1,781 @@
+# 多智能体圆桌研讨 · 前端开发文档
+
+本文档面向维护 `frontend-web` 圆桌规划功能的开发者。后端实现见 `multi-agent-backend-dev.md`；HTTP 字段速查见 `multi-agent-api.md`；推荐弹窗专项进度见 `recommend-agents-progress.md`（若不存在则为待补文件）。
+
+> ⚠️ 历史版本曾引用 `multi-agent-step1-api.md`、`multi-agent-step3-api.md`，当前仓库未提供这两份文件；Step 1（intent）/ Step 3（artifacts）的接口签名直接参考本页第 4 节即可。
+
+---
+
+## 0. 速读：你需要先知道的事
+
+- **三步 UI 通过 `currentStep ∈ {1,2,3}` 切换**，不使用 React Router 子路由。主页面 `RoundtablePlanningPage.tsx`（≈ 1 150 行）只负责组合 + 编排，业务状态全部下沉到三个 hook（见下面）。
+- **业务状态分三块**：`useStep1Intent`（任务理解 + 澄清）、`useStep2Orchestration`（编排循环 + 对话流 + Persona）、`useDraftPersistence`（草稿）。改 Step X 的逻辑请直接进对应 hook，不要回到主页面里写。
+- **消息气泡有共享件**：Step 1 / Step 2 的对话气泡共用 `MessageBubble.tsx` 里的 `MessageBubble` + `MessageLoadingPlaceholder` + `StreamingCursor` + `MarkdownContent`。改气泡通用样式（头像、header、loading、流式 cursor、Markdown 渲染配置）请改这里,不要在两个 Panel 各改一遍。
+- **步骤折叠卡与主聊天对齐**：思考过程 / 工具调用展示走 `MessageStepsCard`,**always-show-last-tool + 折叠 "查看其他 N 个步骤"** 的视觉与主聊天 `chats/new` 的 `MessageGroup` 一致。工具图标 / 文案映射在 `lib/step-display.tsx`,新增工具时与 `src/core/i18n/locales/zh-CN.ts` 的 `toolCalls` 字段对齐。
+- **`<think>` 标签自动提取为「思考过程」**：`lib/reasoning.ts::splitInlineReasoning(text)` 把 `<think>...</think>`(含未闭合的流式中段)抽离成 `reasoning`,正文走 markdown;由 `MessageBubble.tsx::ReasoningBlock` 渲染一个折叠卡。Step 1 / Step 2 气泡和推荐弹窗的 rationale 都走这一套,与主聊天 `Reasoning` 元素的视觉对齐。
+- **不使用 LangGraph SDK**：所有 API 都是自研的 `apiFetch` + `ReadableStream` SSE 解析（见 `api/intent.ts`、`api/recommend.ts`、`api/multi-agent.ts`）。
+- **草稿/历史持久化在后端（2026-06）**：草稿不再存浏览器 `localStorage`，改走后端 MySQL（`/api/roundtable-drafts`，按登录用户隔离、跨设备保留）。`api/drafts.ts` 封装 CRUD，`useDraftPersistence` 异步对接、对外接口不变。**推荐弹窗带「会话级推荐历史」**：每个草稿一串历史，重开弹窗先显示上次推荐结果，可「重新分析」重跑（详见 §5.7 / §6.2）。后端实现见 backend doc 的「圆桌草稿持久化」一节。
+- **不写死模型名**：与 `/page/canvas/ai-writing` 同样的策略 —— 全局选中模型由 `selectedModel` state 维护，首次 `useModels()` 完成后初始化为 `availableModels[0].name`，顶栏「模型」下拉可切换。所有 API 调用统一传 `model: selectedModel || undefined`；后端缺省由 `lead_agent._resolve_model_name()` 回退到 `config.yaml` 的 `models[0]`。**内网部署只需在 `config.yaml` 配自家模型即可，前后端均无需改动**。
+- **席位区间硬约束**：推荐弹窗要求 **2 ≤ 选中数 ≤ 8**（`MIN_SELECTED` / `MAX_SELECTED`）。
+- **协调智能体单例（2026-05）**：`COORDINATOR_AGENT_ID = "roundtable-coordinator"` 是固定常量，不再每会话生成新 id。后端 seeder 自动落地，「本次席位列表」改由后端通过 thread 历史 human 消息注入，前端无感。`newCoordinatorName()` 仅作为兼容性壳保留。
+- **总控编排循环上限**：`MAX_CYCLES = 8`，超出后强制停止并 toast。
+- **席位派活策略**：**顺序**（不是并行）。旧实现并行触发多路 SSE 会让浏览器卡顿，现已改为顺序。
+- **调试开关**：`window.__MULTI_AGENT_INIT_TIMING__` 与 `window.__MULTI_AGENT_DEBUG__`（**不是** `__MULTI_AGENT_STREAM_DEBUG__`，文档历史版本有误）。
+
+---
+
+## 1. 功能定位
+
+**页面路由**：`/page/workspace/roundtable/planning`（侧栏「圆桌规划」）
+
+**入口组件**：`src/roundtable-planning/pages/RoundtablePlanningPage.tsx`
+
+**核心能力**：
+
+| 步骤 | 用户目标 | 真实后端对接 |
+|------|----------|--------------|
+| 1 | 与「任务理解智能体」多轮澄清，得到结构化意图 | `intent.ts` |
+| 1→2 | 从候选池选 2–8 个研讨席位 | `recommend.ts` + `RecommendAgentsDialog` |
+| 2 | 总控派活、子智能体顺序交付、可澄清/挂起 | `multi-agent.ts` + 编排循环 |
+| 3 | 查看总控结论、席位交付、产出文件下载 | `HighFidelityReport` + `listSessionArtifacts` |
+
+**步骤门禁**：
+
+- **Step 2**：`intentReady` 非空才可点击（顶栏按钮禁用 + toast 提示）。
+- **Step 3**：`hasConsensus === true` 才可点击。Leader 派活返回空数组才会自然收敛触发 `hasConsensus`，手动跳转的「达成共识生成全案成果」按钮也会校验。
+
+---
+
+## 2. 目录结构
+
+```
+frontend-web/src/roundtable-planning/
+├── index.ts                            # 导出 RoundtablePlanningPage、HighFidelityReport
+├── pages/
+│   └── RoundtablePlanningPage.tsx      # 主页面：组合 hook + 顶栏/侧栏 + 三步路由（≈1 150 行）
+├── api/
+│   ├── intent.ts                       # Step 1：initIntent、streamIntent
+│   ├── recommend.ts                    # 推荐：streamRecommend、filterRecommendCandidates、parseRecommendStreamContent；**+ 推荐历史 listRecommendHistory / saveRecommendHistory**
+│   ├── drafts.ts                       # **草稿后端 CRUD**：listDrafts / getDraft / createDraft / updateDraft / deleteDraft / deriveDraftName（替代旧 localStorage utils/drafts.ts）
+│   └── multi-agent.ts                  # Step 2/3：initMultiAgent、streamMultiAgent、listSessionArtifacts、buildArtifactDownloadUrl
+├── components/
+│   ├── Avatars.tsx                     # 所有 SVG 头像 + getAvatar 选择器
+│   ├── MessageBubble.tsx               # Step 1/2 共享:消息壳 + loading 占位 + 流式 cursor + MD 配置
+│   ├── MessageStepsCard.tsx            # Step 1/2 共享:工具调用 + 思考过程的折叠卡(对齐主聊天 MessageGroup)
+│   ├── Step1Panel.tsx                  # Step 1 对话面板（不含状态,只读 props）
+│   ├── Step2Panel.tsx                  # Step 2 主面板（圆桌对话流 + 澄清条 + 干预输入）
+│   ├── Step3Panel.tsx                  # Step 3 薄壳,内部仍是 HighFidelityReport
+│   ├── PersonaDrawer.tsx               # Step 2 Persona 抽屉（System Prompt / Temp / Model）
+│   ├── IntentClarificationCard.tsx     # Step 1 选项卡片（单选/多选）+ formatIntentClarificationAnswer
+│   ├── RecommendAgentsDialog.tsx       # Step 1→2 推荐弹窗（含流式 rationale + 候选筛选）
+│   ├── HighFidelityReport.tsx          # Step 3 报告 + 文件清单
+│   ├── ArtifactPreviewModal.tsx        # Markdown/纯文本/JSON/CSV/YAML 等文本类文件 in-app 预览
+│   └── ScrollToBottomButton.tsx        # 对话区「回到底部」浮动按钮
+├── hooks/
+│   ├── useAutoScroll.ts                # 滚动跟随 + 用户上滑暂停跟随
+│   ├── useStep1Intent.ts               # Step 1 状态机:init、send、stream、abort、INTENT_READY 同步
+│   ├── useStep2Orchestration.ts        # Step 2 状态机:initMultiAgent + 编排循环 + 对话流管理 + Persona
+│   └── useDraftPersistence.ts          # 草稿(后端版):异步走 api/drafts;自动保存(前进切换)/手动保存/加载/重命名/删除/ensureDraft
+├── lib/
+│   ├── clarification.ts                # resolveAllowMultiple（单选/多选解析）,与主聊天 ClarificationCard 对齐
+│   ├── reasoning.ts                    # splitInlineReasoning:从模型流式文本里提取 `<think>...</think>` 思考过程
+│   ├── roundtable-constants.ts         # 类型(RoleEntry / SelectedAgent) + 常量 + 纯工具函数(buildRoleTemplates / splitIntentReadyBlock 等)
+│   └── step-display.tsx                # Step 2 ChainOfThought 折叠卡图标 + 文案 + 子节点渲染
+├── utils/                              # （旧 drafts.ts 已删除 —— 草稿改走后端 api/drafts.ts）
+└── styles/
+    └── roundtable-planning.css         # 页面主题变量（浅红品牌色 + 深色覆盖）
+```
+
+**模块依赖方向（自上而下）**：
+
+```
+pages/RoundtablePlanningPage
+   ├─ uses → hooks/useStep1Intent
+   ├─ uses → hooks/useStep2Orchestration
+   ├─ uses → hooks/useDraftPersistence  (依赖 step1 / step2 的 getSnapshot + hydrate)
+   ├─ uses → components/Step{1,2,3}Panel  (纯 props 驱动)
+   ├─ uses → components/RecommendAgentsDialog
+   └─ uses → components/Avatars
+
+hooks/useStep1Intent     → api/intent
+hooks/useStep2Orchestration → api/multi-agent + components/PersonaDrawer 的类型
+hooks/useDraftPersistence → utils/drafts + step1/step2 的 Snapshot 类型
+```
+
+主页面通过 ref 桥接两个 hook 之间的依赖（`buildInitialIntent` 在 Step 2 init 时从 Step 1 状态读取），避免 hook 互相引用造成的循环导入。
+
+**路由注册**（`src/pages/WorkspaceRoutes.tsx`）：
+
+```tsx
+<Route path="roundtable/planning" element={<WorkspaceLayout><RoundtablePlanningPage /></WorkspaceLayout>} />
+```
+
+侧栏入口：`src/components/page-sidebar.tsx` → `/page/roundtable/planning`。
+
+**环境变量**（由 `scripts/start-frontend.sh` 注入）：
+
+- `VITE_BACKEND_BASE_URL` → `getBackendBaseURL()`，所有 API 前缀
+- `VITE_LANGGRAPH_BASE_URL` → 本功能**不**直接用 LangGraph SDK，全部走 Gateway 封装
+
+---
+
+## 3. 三步数据流（前端视角）
+
+```
+[进入 Step 1]
+  useEffect → runStep1Init()
+    initIntent(model) → { agent_id, thread_id }
+    setIntentThreadId、setTimelineEntries
+    interactiveMessages seed 欢迎语（本地 seed，非 API）
+
+[用户发送 / 选项卡片提交]
+  sendIntentMessage(text)
+    追加 user 气泡 + agent 占位（streaming + phase）
+    streamIntent({ onTextDelta, onPhaseChange, signal })
+    终态：
+      done + summary       → setIntentReady，解锁 Step 2 / 推荐弹窗
+      clarification        → IntentClarificationCard + pendingIntentClarificationMsgId
+      asking               → 继续对话
+      error                → toast + 红色 (错误) 文案
+
+[点击「进入多智能体研讨」且 intentReady]
+  setIsRecommendDialogOpen(true)
+  RecommendAgentsDialog
+    listAgents() → filterRecommendCandidates()
+    streamRecommend({ onRationaleUpdate, onPicksUpdate, onPhaseChange })
+    用户勾选 2–8 个 → onConfirm(agentIds)
+  handleConfirmAgents
+    setSelectedAgents(agentIds.map(...))
+    step2InitRef.current = false      // 复位 Step 2 init 闸门
+    setCurrentStep(2)
+
+[进入 Step 2]
+  useEffect（step2InitRef 闸门）→ initMultiAgent(SSE)
+    onSeatReady：右侧席位面板逐个「在线」
+    onCoordinatorReady / init_done → threadIds + coordinatorName
+  runOrchestration(buildInitialIntent(), threadIds, coordinatorName)
+    while !cancelled && cycles<8:
+      leader stream → 若 clarification：暂停循环，展示 Step 2 底部澄清条
+      否则 dispatched[] → **顺序** streamMultiAgent(special) → 再 leader 综合…
+      dispatched.length === 0 → hasConsensus = true，可进 Step 3
+
+[进入 Step 3]
+  HighFidelityReport
+      consensusText ← lastLeaderContent
+      seatDeliveries ← step2RoundtableDialogues.filter(d => d.confidence === "子智能体交付")
+      Object.entries(threadIds).filter(name !== coordinatorName).map → listSessionArtifacts(threadId)
+      文本类文件 → ArtifactPreviewModal；其它 → window.open(downloadUrl)
+  ```
+
+  ---
+
+  ## 4. API 层
+
+  ### 4.1 `api/intent.ts` — Step 1
+
+| 函数 | 说明 |
+|------|------|
+| `initIntent(model?)` | `POST /api/intent/init` → `{ status, agent_id, thread_id }` |
+| `streamIntent(req)` | `POST /api/intent/stream`，读 SSE 至终态帧 |
+
+**`StreamIntentRequest` 重要字段**：
+
+- `threadId`：必填，跨多轮对话保持
+- `signal`：必填（页面通过 `intentAborterRef` 控制暂停 / 切步取消）
+- `onTextDelta(text, messageId)`：每个 AI 文本增量
+- `onPhaseChange(phase, toolName?)`：`connecting → connected → streaming|tool_calling`
+- **`onClarification(clarification, index)`（2026-06）**：每解析到一条 `ask_clarification` 工具结果帧就回调一次，让前端**实时**逐个渲染澄清卡。任务理解智能体**一轮可能问多个问题**，这是「实时接收显示协助过程」的关键入口。
+
+**`StreamIntentResult`**：
+
+| 字段 | 类型 | 说明 |
+|------|------|------|
+| `status` | `"asking" \| "clarification" \| "done" \| "error"` | 终态分支 |
+| `content` | `string` | 完整 AI 文本（含 `[INTENT_READY]` 块） |
+| `summary` | `IntentSummary \| null` | 仅 `done` 有；前端 fallback 也会从 `content` 里用 `splitIntentReadyBlock` 解 |
+| `clarification` | `ClarificationPayload \| null` | **第一个**澄清（向后兼容字段） |
+| `clarifications` | `ClarificationPayload[]` | **本轮全部澄清问题**（2026-06）。来源是流式 `type:"tool"` 帧而非终态帧——**终态帧只带第 1 个**，多问题必须靠它。每条带 `id`（= `tool_call_id`）供前端按题维护选择。 |
+
+**SSE 解析要点**：
+
+- `event: metadata` → phase `connected`
+- `event: messages` + `extractAiTextDelta` → `onTextDelta`
+- `event: messages` + `type:"tool"` 且 `name==="ask_clarification"` → `extractClarificationToolMessage` 解出完整澄清（options 已是 `{id,label}`），按 `tool_call_id` 去重后 `onClarification` 实时回调并收进 `result.clarifications`
+- tool call 帧（`tool_calls` / `tool_call_chunks` 非空）→ phase `tool_calling`（含 `ask_clarification` 工具名）
+- 终态帧识别：`isFinalIntentFrame`（必须有 `status` + `content`）；`status==="clarification"` 且**未**收到任何流式 tool 澄清帧时，才用终态帧字段兜底合成单条澄清
+
+**Abort 行为**：
+
+- `sendIntentMessage` 内建 `AbortController`，保存到 `intentAborterRef`
+- `stopIntentStream()` 用于「暂停」按钮、`currentStep !== 1` 自动调用、`handleStartNewTask`、`handleLoadDraft`
+- 触发 AbortError 时不当作错误：在气泡尾部追加「(已暂停)」并 toast「⏸️ 已暂停任务理解回复」
+
+### 4.2 `api/recommend.ts` — 推荐弹窗
+
+| 函数 | 说明 |
+|------|------|
+| `filterRecommendCandidates(agents)` | 从 `GET /api/agents` 结果剔除 intent / recommender / `roundtable-coordinator-*` |
+| `streamRecommend(req)` | `POST /api/recommend/stream`，无 init（一次性、无状态） |
+| `parseRecommendStreamContent(raw)` | 将累计文本拆成 `{ rationale, picks[] }`，供边流边渲染 |
+
+**`EXCLUDED_AGENT_IDS`** 内置常量（仅 `recommend.ts` 内可见）：
+
+- `roundtable-intent`
+- `roundtable-recommender`
+- 任何以 `roundtable-coordinator-` 开头的 agent_id（动态创建的协调器壳）
+
+**流式 UI 拆分**（与主聊天的 `[RECOMMEND_READY]` 分界类似）：
+
+- 标记常量：`RECOMMEND_READY_MARKER = "[RECOMMEND_READY]"`
+- `parseRecommendStreamContent(raw)`：用 `PICK_OBJECT_PATTERN` 正则增量匹配出已完成的 `{agent_id, reason}` 对象
+- `onRationaleUpdate`：仅 marker 之前的自然语言（弹窗顶部展示）
+- `onPicksUpdate`：从部分 JSON 增量解析 `picks[]`（卡片边流边出，过滤已见 id）
+- 过滤 `TitleMiddleware` 产生的标题增量（`langgraph_node` 含 `TitleMiddleware` 或 `tags` 含 `middleware:title`）
+
+**终态语义**：
+
+- `status === "done"` 且 `picks.length >= 2` → 弹窗用 picks 作为默认勾选
+- 否则 → `phase: "fallback"`，使用 `FALLBACK_AGENT_IDS`（6 个内置 roundtable-* 席位）与候选池交集
+
+### 4.3 `api/multi-agent.ts` — Step 2 & Step 3 文件
+
+| 函数 | 说明 |
+|------|------|
+| `initMultiAgent(payload)` | SSE：`seat_ready`(N 次) → `coordinator_ready` → `init_done` |
+| `streamMultiAgent(req)` | leader / special 一轮 |
+| `listSessionArtifacts(threadId)` | `GET /api/threads/{id}/artifacts` |
+| `buildArtifactDownloadUrl(threadId, virtualPath, { download? })` | 预览或附件下载 URL |
+
+**`initMultiAgent` 事件**（`data:` JSON 的 `event` 字段）：
+
+```ts
+{ event: "seat_ready", agent_name, thread_id, display_name, description }
+{ event: "coordinator_ready", main_agent_name, thread_id }
+{ event: "init_done", main_agent_name, thread_ids }   // thread_ids: Record<agent_name, thread_id>
+{ event: "error", detail }
+```
+
+**`streamMultiAgent` 终态**（`isFinalStatusFrame`）：
+
+| `status` | 含义 | 前端处理 |
+|----------|------|----------|
+| `[["agent","task"], ...]` | 派活列表（数组形态） | **顺序**触发 special；最终用 `nextLeaderTask` 综合 |
+| `[]` | 共识达成（空数组） | `hasConsensus = true`，跳出循环 |
+| `"clarification"` | 总控追问 | `setPendingClarification`，暂停循环 |
+| `"子智能体 X 完成..."` | special 完成 | 更新对应对话气泡 confidence |
+| `"error"` | 失败 | toast + 红色气泡 |
+
+**为什么 special 是顺序而不是并行**：旧版并行触发多路 SSE，每路都在 token 级别对 `step2RoundtableDialogues` 整表 setState，N 个并行 stream 让浏览器卡顿明显。改为顺序后同一时刻只有一个 SSE 在跑，UX 平滑很多（详见 `RoundtablePlanningPage.tsx` 编排循环里的注释）。
+
+**`buildArtifactDownloadUrl` 路径编码**：将 `virtualPath` 按 `/` 切段后逐段 `encodeURIComponent` 再拼回，避免文件名里的中文 / 空格触发后端 404；`download=true` 加在 query string 上而非 path。
+
+**调试开关**：
+
+```js
+window.__MULTI_AGENT_INIT_TIMING__ = true;  // 默认开启；init 各阶段耗时（fetch.start / first-byte / seat_ready#n / coordinator_ready / init_done / total）
+window.__MULTI_AGENT_DEBUG__       = true;  // 默认开启；stream 帧计数 + lastEvent + bad JSON 提示，前缀 [stream:<agentType>:<agentName>]
+```
+
+> ⚠️ 文档历史版本曾写作 `__MULTI_AGENT_STREAM_DEBUG__`，**实际代码并不识别**这个名字。
+
+---
+
+## 5. 主页面状态（`RoundtablePlanningPage`）
+
+> **注意**：自 2026-05 重构后，绝大多数业务状态从主页面下沉到 3 个 hook。下面列出的 state 仍按"位置"分组以便对照原代码，实际所有者请看右列。
+
+| 维度 | 所有者 | 暴露给主页面的方式 |
+|------|--------|-------------------|
+| `currentStep`、`showToast`、`selectedModel`、`roles`、`isRecommendDialogOpen` | 主页面 | useState |
+| Step 1 全部 state + handler | `useStep1Intent` | hook 返回值 |
+| Step 2 全部 state + handler + 编排循环 | `useStep2Orchestration` | hook 返回值 |
+| 草稿(drafts / currentDraftId / 重命名 / 历史下拉) | `useDraftPersistence` | hook 返回值 |
+| `loadedFromDraftRef` 共享 latch | `useDraftPersistence` 拥有,Step 2 init effect 通过 options 读 | hook 间共享 ref |
+
+### 5.1 步骤与门禁
+
+- `currentStep`: `1 | 2 | 3`
+- **Step 2 锁定**：`intentReady == null` 时顶栏 Step 2 按钮禁用（visual + `aria-disabled`），同时点击「进入多智能体研讨」会 toast 「⚠️ 请先与任务理解智能体完成澄清…」
+- **Step 3**：`hasConsensus === false` 时顶栏 Step 3 与底部「达成共识生成全案成果」按钮均禁用
+
+### 5.2 Step 1 关键 state
+
+| 状态 | 用途 |
+|------|------|
+| `intentThreadId` | `/api/intent/init` 返回的线程 id；未就绪前发送按钮置灰 |
+| `intentReady` | `IntentSummary`，驱动 Step 2 初始 prompt + 右侧摘要面板 + 顶栏 step2 解锁 |
+| `interactiveMessages` | 问答气泡列表（user / agent，含 streaming/phase/clarification 元数据） |
+| `pendingIntentClarificationMsgId` | 当前可操作的 agent 消息 id（保证只有最新一条 clarification 展示可点卡片） |
+| `intentClarificationSelections` | `Map<msgId, {selectedIds, custom}>`，多选 / 多消息时各自维护 |
+| `isIntentSending` | 发送中（屏蔽双发 / 显示「暂停」按钮） |
+| `intentAborterRef` | 当前 stream 的 AbortController |
+| `intentInitError` | init 失败信息；驱动右侧角色面板「异常」状态与红色提示 |
+| `step1InitRef` | 闸门：true 即认为已 init 过 |
+| `step1InitGenRef` | **单调递增**的代数标记，详见下文 |
+| `timelineEntries` | 右侧「澄清记录」时间线（init / user 反馈 / 任务意图已明确） |
+
+**`step1InitGenRef` 的存在原因**：
+
+React 18 StrictMode 开发环境下，effect 会 mount → cleanup → mount 两次。早期实现用闭包 `cancelled` 标志做防抖，结果是：第二次 mount 因 `step1InitRef.current === true` 早返回，但第一次 mount 的 async 仍未完成；当它最终 resolve 时，`cancelled` 已被 cleanup 置 true，因此 `setIntentThreadId` 被跳过，右栏卡在「正在上线」。改为单调代数后：每次 `runStep1Init` 自增 `step1InitGenRef`；async 完成时检查 `myGen === step1InitGenRef.current`，等价于「我是当前最新一次 init」，否则丢弃结果。这也覆盖了「新建任务 / 加载草稿期间旧 init 晚归」的场景。
+
+**`splitIntentReadyBlock(text)`**（页面内工具函数，使用 `INTENT_READY_RE` 正则）：
+
+- 从气泡正文解析 `[INTENT_READY]\n```json\n{...}\n``` ` 块
+- 返回 `{ before, summary, after }`，前后文与结构化卡片分别渲染
+- 单独的 `useEffect` 监听 `interactiveMessages`：若已存在含 `[INTENT_READY]` 的 agent 消息但 `intentReady` 仍为 null（极少数终态帧丢 summary 的场景），主动 `setIntentReady`，与后端 "READY 优先" 对齐
+
+### 5.3 推荐与 Step 2 席位
+
+| 状态 | 用途 |
+|------|------|
+| `selectedAgents` | `{ agent_id, name }[]`，默认 `DEFAULT_SELECTED_AGENTS`（6 内置） |
+| `roleTemplates` / `roles` | 右侧席位面板（`buildRoleTemplates`，commander 占 id=1，agents 从 id=2 开始） |
+| `agentNameToRole` | 流式输出时根据 `agent_name`（小写）反查 speakerId、avatarType、displayName |
+| `roundtableAgentIds` | `selectedAgents.map(a => a.agent_id)`，传给 `/api/multi-agent/init` 的 `agent_names` |
+| `threadIds` / `coordinatorName` | `/api/multi-agent/init` 结果；离开 Step 2 **不**清空，允许回来继续看 |
+| `step2RoundtableDialogues` | Step 2 对话流（含 `streaming` / `confidence` / `time` / `avatarType`） |
+| `lastLeaderContent` / `hasConsensus` | Step 3 总控结论 + 共识标记 |
+| `pendingClarification` | Step 2 总控澄清（复用 `ClarificationPayload`） |
+| `clarificationDraft` | 底部自定义回答输入框（受 `allowCustom` 控制） |
+| `isRoundTableRunning` | 用户挂起 / 恢复协商的 UI 开关 |
+| `isOrchestrating` | 编排循环正在 run（屏蔽并发触发） |
+| `orchestrationCancelRef` | 与 `abortAllInFlight` 配合中断当前循环 |
+| `activeAbortersRef` | 当前 Step 2 所有 in-flight stream 的 AbortController 集合 |
+| `activeSpeakerId` / `activeSpeakerSet` | 圆桌可视化高亮：单 leader 时用单值，多席位并行时用 Set |
+| `selectedAgentId` | 当前 Persona 抽屉所在的席位 id（点击圆桌头像打开） |
+| `agentConfigs` | `Map<seatId, {model, weight, prompt, temp}>` Persona 覆盖；下一轮该席位的派活会用此 model |
+| `isUpperPanelCollapsed` | 是否折叠圆桌可视化 + 调控台，给对话区让出垂直空间 |
+
+**协调智能体命名（2026-05 改造）**：现在是**固定单例 id** `roundtable-coordinator`（见 `lib/roundtable-constants.ts::COORDINATOR_AGENT_ID`）。`newCoordinatorName()` 函数为兼容性保留，内部直接返回这个常量字符串。后端 `ensure_roundtable_functional_agents()` 缺失自动落地，不再每次新建。`filterRecommendCandidates` 在 `EXCLUDED_AGENT_IDS` 集合里同时排除：
+
+- `roundtable-coordinator`（新版单例 id，永远过滤）；
+- `roundtable-coordinator-*` 前缀（历史残留，管理员清理之前先在 UI 隐藏）。
+
+> 历史草稿兼容性：用户加载 2026-05 前保存的草稿时，存储的 `coordinatorName` 仍是 `roundtable-coordinator-<ts36>` 形式。只要那个旧 agent 目录还在磁盘上（即运维没手动删过），加载后继续在 Step 2 干活就能正常工作；如果旧 agent 被清理掉了，需要让用户「重新起草」从头跑一遍 Step 1 → Step 2。
+
+### 5.4 编排循环 `runOrchestration(seedMessage, ids, coord)`
+
+伪代码：
+
+```
+isOrchestrating = true
+orchestrationCancelRef = false
+nextLeaderTask = seedMessage
+cycles = 0
+MAX_CYCLES = 8
+
+while !cancelled && cycles < MAX_CYCLES:
+  cycles += 1
+  highlight(speakerId=2)   // 总控
+  leaderBubble = appendStreamingDialogue("总控协调", confidence: "调度中")
+  res = streamMultiAgent(leader, ids, coord, nextLeaderTask, onTextDelta, onPhaseChange)
+
+  if res.clarification:
+    finalize(leaderBubble, content, "等待用户澄清")
+    setPendingClarification(res.clarification)
+    break        // 等用户回复后由 submitClarification 重启循环
+
+  finalize(leaderBubble, content, dispatched.length === 0 ? "全案盖印" : "派活说明")
+  if res.content: setLastLeaderContent(res.content)
+
+  if res.dispatched.length === 0:
+    setHasConsensus(true); setConsensusPercentage(100); break
+
+  for [subName, task] of res.dispatched:        // **顺序**，不是并行
+    meta = agentNameToRole[subName.toLowerCase()]
+    markSpeakerStreaming(meta.speakerId)
+    perSeatModel = agentConfigs[meta.speakerId]?.model || DEFAULT_MODEL
+    subBubble = appendStreamingDialogue(meta.displayName, confidence: "调度中")
+    specRes = streamMultiAgent(special, ..., perSeatModel, signal=subAborter)
+    finalize(subBubble, specRes.content, "子智能体交付")
+    markSpeakerIdle(meta.speakerId)
+    if cancelled: break
+
+  setConsensusPercentage(prev => min(95, prev + 8))
+  nextLeaderTask = "各子智能体已就上一轮派活完成交付,请你结合最新结论..."
+
+if cycles >= MAX_CYCLES:
+  toast("⏱️ 已达到最大研讨轮次,自动停止以避免循环")
+
+clearAllStreamingSpeakers()
+isOrchestrating = false
+```
+
+要点：
+
+- **`buildInitialIntent()`**：
+  - 有 `intentReady` → 拼装 `objective / 约束条件 / 关键假设` + 「不要再反问用户」终结语
+  - 无 `intentReady`（用户跳过澄清 / 顶栏直接切到 Step 2）→ 拼接 Step 1 内 `interactiveMessages` 里 sender==='user' 的内容，逐行 `用户#N: ...`，**绝不**注入 mock 的「预算 500 万 / 72 小时」数字
+  - 用户输入完全为空 → 让总控先调用 `ask_clarification` 而不是凭空派活
+- **用户「干预研审」**：`handleInjectToRoundtable` 追加一个「💡 (人工指令介入) ...」气泡，然后构造 `runOrchestration("用户人工干预新指令:...", ...)`
+- **挂起 / 恢复**：
+  - 挂起 = `setIsRoundTableRunning(false)` → `stopOrchestration()` → `orchestrationCancelRef = true` + `abortAllInFlight()`
+  - 恢复 = `setIsRoundTableRunning(true)`，effect 触发 `runOrchestration("用户已恢复研讨,请继续上一轮的协调工作。", ...)`
+- **澄清恢复**：`submitClarification` 把用户回答拼到 prompt 里再 `runOrchestration`，不会重建 thread
+
+### 5.5 Persona 抽屉（Step 2 圆桌可视化点击）
+
+- 点击圆桌头像 → `setSelectedAgentId(seatId)` → 在上半部分下方展开抽屉
+- 抽屉控件：
+  - **System Prompt**：仅前端记录（后端覆写未开放）
+  - **Temp**：仅前端记录
+  - **推理模型**：选项来自 `useModels()`；显示值优先级 `agentConfigs[seat]?.model > selectedModel`
+- 「参数覆盖并重启动算研讨」按钮 → `handleSaveAgentAndRecalculate`：
+  - 把新的 `(seatId, model)` 写入 `agentConfigs`
+  - 追加一条「⚡ [模型偏好已保存] ...」对话气泡
+  - **不**立即重启编排；下一轮该席位被派活时 `runOrchestration` 内会读 `agentConfigs[meta.speakerId]?.model || selectedModel || undefined` 作为 special 调用的 `model` 参数
+
+### 5.6 全局模型选择器（右侧 sidebar 顶部）
+
+- **位置**：右侧 sidebar `currentStep !== 3` 时显示的第一个面板 —— 在「当前意图摘要」**正上方**。Step 3 时整个 sidebar 切换成「最终共识结论 / 风险与预算摘要 / 导出与交付」，所以模型选择器仅在 Step 1 / Step 2 可见（此时也是唯一会发起新模型调用的阶段）
+- **state**：`const [selectedModel, setSelectedModel] = useState<string>("")`
+- **初始化**：`useEffect(() => ...)` 在 `availableModels` 首次返回后把 `selectedModel` 设为 `availableModels[0].name`；后端配置变化导致当前选中 model 不在列表里时也回退到首项
+- **传参规则**：所有 5 个 API 调用点（`initIntent` / `streamIntent` / `streamRecommend` / `initMultiAgent` / `streamMultiAgent` leader / `streamMultiAgent` special）都传 `selectedModel || undefined`；special 还会先看 `agentConfigs[seat]?.model` per-seat 覆盖
+- **禁用态**：`availableModels.length === 0` 或 `modelsLoading` → `disabled`，placeholder 显示「加载中…」或「未配置模型」
+- **可改换为 Radix Select**：当前用原生 `<select>` 与 Persona 抽屉保持一致；如需统一样式可改为 `@/components/ui/select`，行为不变
+
+### 5.7 草稿持久化（`api/drafts.ts` + 后端 MySQL，2026-06 改造）
+
+> **重大变更**：草稿从浏览器 `localStorage` 迁到**后端 MySQL**，按登录用户隔离、跨设备/会话保留。旧 `utils/drafts.ts` 已删除；`useDraftPersistence` 仍保持对外接口不变（列表项含 `name`，由后端 `title` 映射而来），主页面无需改动。后端表/路由见 backend doc「圆桌草稿持久化」。
+
+- **API 客户端 `api/drafts.ts`**：`listDrafts()`（轻量元数据）/ `getDraft(id)`（全量 step1+step2）/ `createDraft` / `updateDraft`（partial）/ `deleteDraft` / `deriveDraftName`。snake_case↔camelCase 映射在这一层收口（后端 `furthest_step/created_at/updated_at` ↔ 前端 `furthestStep/...`）。
+- **快照形状**：`DraftStep1Snapshot.{intentThreadId, intentReady, interactiveMessages, timelineEntries}`、`DraftStep2Snapshot.{selectedAgents, threadIds, coordinatorName, step2RoundtableDialogues, lastLeaderContent, hasConsensus, consensusPercentage, budgetLimit, seatStubMessages, orchestrationMode?, chain?}`；以 JSON 整存进后端 `step1`/`step2`（`PortableLongText`/LONGTEXT，避免大对话超 64KB）。
+  - **`selectedAgents`（2026-06 修复）**：本次研讨实际选中的席位。**不存的话加载草稿后 Step 2/3 左侧「参与角色」会回退到 `DEFAULT_SELECTED_AGENTS`（默认 6 个）而非当时真正选的那几个** —— `roleTemplates`/`agentNameToRole` 都由 `selectedAgents` 派生。`useStep2Orchestration.hydrateFromDraft` 在该字段非空时 `setSelectedAgents`，老草稿（无此字段）保持当前值不强行覆盖。
+  - **`orchestrationMode?` / `chain?`（2026-06 业务链条）**：Step 2 编排模式（`recommend`=总控自由派活 / `chain`=按业务链条顺序派活）+ 来源链条 `{id,title}`。是**主页面 state**，由页面在 `getStep2Snapshot` 写入、在**包裹版 `hydrateStep2`** 里读出后 `setOrchestrationMode`/`setChainMeta`（step2 hook 的 `hydrateFromDraft` 不直接消费）。老草稿无字段 → 默认 `recommend`。业务链条完整设计见 `multi-agent-business-chain-dev.md`。
+- `deriveDraftName({intentReady, interactiveMessages})`：优先 `intentReady.objective`，否则第一个 user 消息，否则 `未命名草稿 <时间>`，截断 40 字。**仅在 create 时写一次**（见下方 bug 修复）。
+- **列表加载**：挂载时 `useEffect` 调 `listDrafts()`；增删改后 `refreshList()` 重拉。
+- **自动保存策略**：仅在「前进」步骤切换时保存（1→2、2→3），后退不触发。
+- **手动保存 / `ensureDraft`**：`handleManualSave` 走同一条保存队列；`ensureDraft(furthestStep?)` 幂等保证后端有一条对应草稿并返回 id（**推荐弹窗打开前调用**，让推荐历史有 `draft_id` 归属）。
+- **加载草稿 `handleLoadDraft`**：
+  - 走 `getDraft(id)` **实时拉服务端最新全量**（不再读内存里可能过期的列表快照）；404 → toast「草稿已不存在」并刷新列表。
+  - **先**置 `loadedFromDraftRef.current = true`，再 `setCurrentStep(draft.furthestStep)`（顺序不能反）。
+  - `setStep2InitGate(draft.furthestStep >= 2)`：曾走到 Step 2 才跳过自动 init。
+  - 角色面板基线：被恢复时全部「在线」，否则 init 流程逐个「在线」。
+
+**本次随手修复的 4 个旧 localStorage 版 bug**（对接后端时一并解决）：
+
+1. **自动保存覆盖手动重命名** —— 现在所有 `updateDraft` 一律**不带 title**；标题只由 create（派生）与显式「重命名」改写。
+2. **快速连续前进（1→2→3）产生重复草稿** —— 所有保存经一条**串行队列**（`saveQueueRef`）+ 同步镜像 `currentDraftIdRef`，create 完成即写 id，后续保存读到 id 走 update 而非再 create。
+3. **加载读到内存旧列表快照** —— 改为 `getDraft(id)` 实时拉。
+4. **localStorage 配额静默写失败 / 数据丢失** —— 迁后端后不复存在。
+
+---
+
+## 6. 组件说明
+
+### 6.1 `IntentClarificationCard`
+
+- Props：`payload`（`ClarificationPayload`）、`selection`、`onSubmit(overrideSelection?)`、`disabled`、`submitting`、`fallbackContent`、**`deferSubmit?`（2026-06）**
+- **单选**（默认 `allowMultiple === false`）：`resolveAllowMultiple` 返回 false → 点击选项即 `onSubmit({selectedIds:[id], custom: ""})`，UI 不显示「发送回答」按钮（除非 `allowCustom`）
+- **多选**：勾选多个 + 输入补充，再点「发送回答」；答案格式见 `formatIntentClarificationAnswer`：
+  - 仅选项 → `我选择：A、B`
+  - 仅自定义 → 直接发自定义文本
+  - 同时存在 → `我选择：A、B；补充：…`
+- **单问题 vs 多问题的判断（2026-06）**：`Step1Message` 按 `clarifications.length` 分流，**默认单选**（后端 `allow_multiple` 缺省 false，`resolveAllowMultiple` 兜底）：
+  - **单问题（最常见）**：`deferSubmit={false}`，沿用原交互 —— 单选**点击选项即发送**；多选 / 允许自定义则走卡片自带的「发送回答」按钮。**不**显示合并按钮。
+  - **多问题**：`deferSubmit={true}` —— 连单选点击也只**记录**选择（不立即发送），卡片自身隐藏按钮；父组件在卡片下方渲染**一个**「发送全部回答」按钮，统一提交。
+  - 该判断纯在前端（不动工具/后端）：依据 `clarifications.length` + `allow_multiple`，后端 `ask_clarification` 本就默认单选。
+- **合并提交逻辑**：`submitIntentClarifications(msgId, clarifications, overrideByKey?)` 逐题取选择、格式化、拼成一条消息（多题带 `1. <问题>\n答:<答案>` 编号；单题直接发答案；至少答一题才发）。`overrideByKey` 供「单题单选点击即发送」用——此时选择还没写进 state map（setState 异步），把即时选择按 `clarificationKey` 传进去直接用。
+  - **逐题选择隔离**：选择 Map 改为 `Map<string, IntentClarificationSelection>`，key 由 `clarificationKey(msgId, clar.id, index)` 生成（`clar.id` = `tool_call_id`，缺省退化为 `idx-N`）。
+- 展示条件：`isAgent && clarifications.length>0 && !intentReady && !parts.summary`；**流式期也展示**（卡片 `disabled`，只读，体现「协助过程」实时出现），仅当终态且 `pendingIntentClarificationMsgId === msg.id && !streaming` 时才可交互。出现 `[INTENT_READY]` / summary 后隐藏。
+- **步骤链强化**：`onClarification` 同时往 `msg.steps` 追加一条 `追问 N:<问题>`，让 `MessageStepsCard` 把每个 `ask_clarification` 调用显示成独立步骤。
+
+### 6.2 `RecommendAgentsDialog`
+
+> **席位来源选择器（2026-06 业务链条）**：弹窗顶部加了**模式分段切换** `智能推荐 | 业务链条`。智能推荐 = 本节描述的现状（零行为变更，整体收进 `{mode==="recommend"}` 分支）；业务链条 = `BusinessChainPicker`（选一条已配置链条，卡片标题 + 彩色席位 tag + `→` 箭头）。`onConfirm` 统一回传 `SeatSelectionResult{ agents, mode, chain? }`；`mode==="chain"` 时 Step 2 由总控**按链条顺序派活**（`useStep2Orchestration.runChainOrchestration`）。配置页与编排详见 `multi-agent-business-chain-dev.md`。
+
+- **新增 `draftId` prop（2026-06）**：本次推荐归属的草稿/会话 id。由主页面在打开弹窗前 `await drafts.ensureDraft(1)` 拿到并传入（见 §6.6）。`null` 时退化为「直接推荐、不存历史」的旧行为。
+- 打开时管线（`start(forceFresh=false)`）：`listAgents() → filterRecommendCandidates()` → **若 `draftId` 有历史 → `listRecommendHistory()` 取最近一次直接展示（不重跑模型）**；否则 `streamRecommend()` 跑新推荐。
+- 阶段 UI（`InternalState.phase`）：
+  - `idle` → `loading_agents` → **`loading_history`** → **`history`**（展示上次推荐，可直接进入研讨或「重新分析」）
+  - 或 `loading_agents` → `recommending`（顶部「模型生成内容」流式；推荐卡 streaming=true）→ `ready` / `fallback` / `error`
+- **推荐历史（会话级）**：
+  - 打开时若该 `draftId` 有历史，进入 `history` 态：蓝色提示条标注上次推荐时间，picks 默认勾选、rationale 回显，**不**自动重跑模型。
+  - 「**重新分析**」按钮（`history` 态显示该文案，其它态为「重新推荐」）→ `start(true)` 强制跑新推荐，跳过历史。
+  - 每次**新推荐**完成（`ready`/`fallback`）后 `saveRecommendHistory(draftId, {objective,status,model,rationale,picks,candidates})` best-effort 追加一条（失败仅告警不阻断）。
+  - `history`/`fallback`/`ready` 三态都允许 `onConfirm`（用户可直接采纳历史 picks）。
+- **布局分两段**：
+  - **顶部「模型生成内容」**：`RecommenderOutput` —— 状态行（`spinner + 调度推荐 / 已连接 / 正在生成`）+ `MessageStepsCard` 步骤卡 + `ReasoningBlock`（从 `<think>` 拆出来）+ markdown rationale + 末尾 `StreamingCursor`。视觉与 Step 1/Step 2 气泡的内容区一致，参考主聊天 `chats/new`。
+  - **底部「推荐参会智能体」**：候选卡片(`AgentCard`),分「推荐参会 / 其他候选」两组。
+- 选择约束：`2 ≤ selected ≤ 8`；底部实时显示「至少再选 N 个」「已选 X / 8」
+- 失败兜底：候选为空 → error；status==="asking" 或 picks 不足 2 → `fallback`，自动用 `FALLBACK_AGENT_IDS` 与候选池交集勾选
+- 反竞态：内部 `generationRef`，每次 `start()` 自增，所有 setState（含历史读取/流式回调）都校验 `myGen === generationRef.current`，避免「重新分析」时旧 stream / 旧历史写脏 state
+- `onConfirm(agentIds)` → 父组件 `handleConfirmAgents`：复位 `step2InitRef` 并 `setCurrentStep(2)`，触发 Step 2 init
+
+### 6.3 `HighFidelityReport`（Step 3）
+
+- 输入：`threadIds`、`coordinatorName`、`consensusText`、`hasConsensus`、`seatDeliveries`、`seatNameMap`、`onReset`
+- `seatThreadEntries`：过滤掉 `coordinatorName`，给每个 sub-thread 拉一次 `listSessionArtifacts`（`Promise.all` 并行）
+- `reloadKey`：「刷新文件清单」按钮自增，触发 effect 重新拉
+- **文件预览策略**（`shouldPreviewInModal`）：
+  - 命中 → `ArtifactPreviewModal`（Markdown 用 react-markdown 渲染，其它当 plain text）
+  - 不命中（pdf / png / html / 二进制）→ `window.open(buildArtifactDownloadUrl)`，交给浏览器原生 viewer
+  - 命中规则：
+    - mimeType 是 `text/markdown` / `text/plain` / `text/csv` / `application/json` / `text/*`
+    - 或文件名后缀属于 `md / markdown / txt / json / csv / log / yml / yaml / xml`
+- 各席位最终交付（中段折叠区）数据源：父组件传入的 `seatDeliveries`，按发送者去重（后到的覆盖前者）
+- 「重新起草」→ 父组件 `handleStartNewTask`（清空并 `runStep1Init`）
+- 「打印 / 另存 PDF」→ `window.print()`，浏览器原生流程
+- **Step 3 不显示左侧栏（2026-06）**：`LeftSidebar` 在 `currentStep === 3` 时 `return null`（原「参与与结论贡献」列已移除），右侧栏在 Step !== 1 时本就 `return null`，因此中间 `middle-viewport`（`flex-1`）会自适应撑满整行，报告区获得最大宽度。
+
+### 6.4 `ArtifactPreviewModal`
+
+- 通过 `buildArtifactDownloadUrl(threadId, path)`（不带 `download=true`）GET 文件正文
+- Markdown 文件（mime===`text/markdown` 或后缀 `.md/.markdown`）→ react-markdown + remark-gfm
+- 其它文本类 → `<pre>` 直出
+- 头部「下载」按钮单独走 `download=true` URL，触发浏览器附件下载
+- 关闭：Esc / 点击外层遮罩（精确匹配 `e.target === e.currentTarget`，避免内部冒泡误关）
+
+### 6.5 共享 UI 模式与辅助
+
+- **三段式流式气泡**：`appendStreamingDialogue` → `appendToDialogue`（仅追加增量）→ `finalizeDialogue`（设最终 content + confidence + `streaming=false`）。三函数都通过 `id` 匹配，避免数组下标错位
+- **Phase 到中文文案**：`phaseLabel(phase, agentType, toolName)`：
+  - `connecting` → 「调度中」
+  - `connected` → 「已连接,等待响应」
+  - `tool_calling` 按 toolName：`agent_orchestration → 正在派活`、`ask_clarification → 正在提问`、`present_files → 正在交付文件`，其它 → 「调用工具:<name>」
+  - `tool_result` → 「处理工具结果」
+  - `streaming` → leader 时「正在派活说明」、special 时「正在输出」
+  - Step 1 的 `intentPhaseLabel`：`ask_clarification → 正在生成追问`、`streaming → 正在思考问题`
+- **Markdown 渲染**：Step 1 / 2 / 3 都用 `react-markdown` + `remark-gfm`，自定义紧凑间距的 `components`（`p` 用 `my-1 whitespace-pre-wrap` 等）
+- **自动滚动**：`useAutoScroll(ref, [list])` 跟随；用户上滑后停止跟随；`ScrollToBottomButton` 一键回底
+- **`activeSpeakerSet`**：圆桌可视化里多席位同时高亮需要 Set，单 leader 时仍可用 `activeSpeakerId`；两者均触发 ring 动画
+- **状态条颜色**：`研讨中` 红 / `在线` 绿 / `已完成` 绿勾 / `正在上线` 黄旋 / 其它灰
+
+---
+
+## 7. 澄清交互（与主聊天对齐）
+
+| 能力 | 实现位置 |
+|------|----------|
+| 结构化 payload 类型 | `multi-agent.ts` → `ClarificationPayload`（intent.ts 复用） |
+| 单选/多选 | `lib/clarification.ts` → `resolveAllowMultiple`（缺省单选） |
+| 答案拼接 | `formatIntentClarificationAnswer`（`IntentClarificationCard`） |
+| Step 1 卡片 | `IntentClarificationCard` + `submitIntentClarification` |
+| Step 2 卡片 | 页面底部 `pendingClarification` 区块 + `submitClarification` → 再 `runOrchestration` |
+| 主聊天参考 | `src/components/workspace/messages/message-list.tsx` → `ClarificationCard` |
+
+后端字段 `allow_multiple` 缺省为 **false**（单选、点击即发送）。
+
+**关键差异**：
+
+- Step 1 用 `IntentClarificationCard` 组件（嵌在气泡里），Step 2 直接在页面底部渲染 amber 色带（**没有**抽象成独立组件，紧贴对话区）。
+- Step 2 澄清回复后**不**重建 thread；新 prompt 自带「用户已回复你刚才的澄清问题。问题:... 用户回答:...」上下文。
+
+---
+
+## 8. 与主聊天的差异
+
+| 维度 | 主聊天 `/page/workspace/chats/new` | 圆桌规划 |
+|------|-----------------------------------|----------|
+| SDK | `@langchain/langgraph-sdk` 直连 | 自研 SSE 解析（`apiFetch` + ReadableStream） |
+| 澄清展示 | `message-list` ToolMessage `additional_kwargs` | 终态帧 `status: "clarification"` |
+| Agent | 用户可选 assistant | 内置 intent + 动态 coordinator + 可选席位 |
+| 线程 | 单 thread | Step 1 一线程；Step 2 每席位 + 协调各一线程 |
+| 终态语义 | LangGraph state | 自定义 `{status, content, ...}` 终态帧 |
+| 暂停 | LangGraph interrupt | `AbortController.abort()` |
+
+复用思路：澄清卡片交互、答案文案格式；**不要**假设能直接复用 LangGraph React hooks。
+
+---
+
+## 9. 关键交互清单
+
+| 交互 | 行为 |
+|------|------|
+| Step 1 发送 | Enter 发送（Shift+Enter 换行）；发送中显示「暂停」 |
+| Step 1 暂停 | `stopIntentStream()`，气泡尾部追加 `(已暂停)` 并 toast |
+| Step 1 进入 Step 2 | 需 `intentReady`；打开推荐弹窗而非直接切步 |
+| Step 1 跳过此项 | 仅本地追加「系统」气泡，不发请求；适合演示 |
+| Step 2 init | 首次进入自动 SSE init；离开 Step 2 **不**销毁 `threadIds`（可返回继续看，不会二次 init） |
+| Step 2 挂起/恢复 | `isRoundTableRunning` + `stopOrchestration` / 恢复时再 leader 一轮 |
+| Step 2 干预 | 底部输入框 → `runOrchestration` 新 seed，wrap 进「用户人工干预新指令:...」 prompt |
+| Step 2 Persona | 点圆桌头像打开抽屉；保存后下一轮该席位使用所选模型 |
+| 新建任务 | `handleStartNewTask`：abort 全部、清 state、`runStep1Init`，与 Step 3「重新起草」共用 |
+| 历史草稿 | 顶栏下拉：加载 / 重命名 / 删除（删除带 `window.confirm`） |
+| Step 3 预览 | 文本类 → 模态预览；其它 → 新窗口下载 |
+
+---
+
+## 10. 类型与常量速查
+
+```ts
+// Step 1 输出 → Step 2 输入
+interface IntentSummary {
+  objective: string;
+  constraints: string[];
+  assumptions?: string[];
+}
+
+// Step 2 线程映射（init_done.thread_ids）
+type ThreadIdMap = Record<string, string>;
+
+// 派活
+type LeaderDispatch = [string, string]; // [agent_name, task]
+
+// 当前选中的研讨席位
+type SelectedAgent = { agent_id: string; name: string };
+
+// Step 1 单条澄清问题
+interface ClarificationPayload {
+  question: string;
+  clarificationType: string;
+  context: string;
+  options: unknown[];
+  allowCustom: boolean;
+  allowMultiple?: boolean;
+}
+
+// Step 2 stream 终态
+interface StreamMultiAgentResult {
+  dispatched: LeaderDispatch[];
+  message: string | null;
+  content: string;
+  agentName: string | null;
+  clarification: ClarificationPayload | null;
+}
+```
+
+**核心常量**：
+
+| 常量 | 值 | 位置 |
+|------|----|------|
+| `COMMANDER_SEAT_ID` | `1` | RoundtablePlanningPage |
+| `MAX_CYCLES` | `8` | RoundtablePlanningPage（`runOrchestration` 内） |
+| `MIN_SELECTED` / `MAX_SELECTED` | `2` / `8` | RecommendAgentsDialog |
+| `FALLBACK_AGENT_IDS` | 6 内置 roundtable-* | RecommendAgentsDialog |
+| `BUILTIN_AGENT_META` | 6 内置头像/中文名 | RoundtablePlanningPage |
+| `FALLBACK_AVATAR_TYPES` | `[blue, purple, emerald, amber, pink]` | RoundtablePlanningPage |
+| ~~`STORAGE_KEY`~~ | 已废弃 —— 草稿改存后端 `/api/roundtable-drafts`，不再用 localStorage | （旧 utils/drafts.ts，已删除） |
+| `INTENT_READY_RE` | `/\[INTENT_READY\]\s*```json\s*(\{[\s\S]*?\})\s*```/` | RoundtablePlanningPage |
+| `RECOMMEND_READY_MARKER` | `"[RECOMMEND_READY]"` | recommend.ts |
+| `EXCLUDED_AGENT_IDS` / 前缀 | `roundtable-intent`、`roundtable-recommender`、`roundtable-coordinator-*` | recommend.ts |
+
+---
+
+## 11. 故障排查
+
+| 现象 | 可能原因 | 排查 |
+|------|----------|------|
+| Step 1 一直「等待澄清」但气泡里出现绿色 [INTENT_READY] 摘要 | 终态帧未带 `summary` | 看 `splitIntentReadyBlock` + 同步 `useEffect`，必要时手动刷新 |
+| Step 1 角色面板卡在「正在上线」 | StrictMode 双 mount 导致 init 异步被丢弃 | 已用 `step1InitGenRef` 修复；检查是否被改坏 |
+| 选项全是多选 | `allow_multiple` 未传或为 true | Network 终态帧；`resolveAllowMultiple` |
+| Step 2 init 卡住 | init SSE error / 代理 | Network `init`；控制台 `[init-timing]` |
+| Step 2 stream 看不到任何文字 | TitleMiddleware 过滤错杀 / phase 卡在 connecting | 控制台搜 `[stream:` 前缀（需 `__MULTI_AGENT_DEBUG__`） |
+| 总控不派活 | `dispatched` 一直 `[]` 且非 clarification | 看 leader 终态帧；模型 SOUL 配置 |
+| 推荐弹窗为空 | `filterRecommendCandidates` 把所有候选都过滤了 | `GET /api/agents` 列表；检查 `EXCLUDED_AGENT_IDS` |
+| 推荐弹窗一直「等待推荐结果」 | recommender 模型死循环 | 控制台看 `[stream:` 日志，或点「重新推荐」 |
+| Step 3 各席位文件为空 | 子 agent 未写 outputs 或 thread id 错 | 对应 thread 调 `listSessionArtifacts` |
+| Step 3 预览空白 | 文件不是文本类，但被错误命中 `shouldPreviewInModal` | 检查 mime + 后缀；不在白名单的应该跳 `window.open` |
+| Step 3 文件名乱码 / 404 | `buildArtifactDownloadUrl` 编码错 | 看 path 是否被分段 encode；不能整体 encode（会把 `/` 也编了） |
+| 草稿加载后重复 init | `loadedFromDraftRef` 未置位 | `handleLoadDraft` 流程，注意 ref 必须先于 `setCurrentStep` |
+| 顶栏 Step 2 / Step 3 一直灰 | `intentReady` / `hasConsensus` 没设上 | 看终态帧；leader.dispatched 是否真为 `[]` |
+| Persona 抽屉改模型不生效 | 下一轮才生效 / 抽屉 model 未传给 streamMultiAgent | 看 `agentConfigs[meta.speakerId]?.model` 的传递路径 |
+| 并行 SSE 卡顿 | 误改为 parallel 派活 | 保持顺序 dispatch，详见 §5.4 注释 |
+
+**本地调试开关**：
+
+```js
+window.__MULTI_AGENT_INIT_TIMING__ = true;  // init 各阶段耗时（默认开）
+window.__MULTI_AGENT_DEBUG__       = true;  // stream 帧计数（默认开）
+```
+
+---
+
+## 12. 扩展指南
+
+### 12.1 新增默认研讨席位
+
+1. 后端 `.deer-flow/agents/roundtable-xxx/`
+2. `BUILTIN_AGENT_META` + `DEFAULT_SELECTED_AGENTS` + `RecommendAgentsDialog` 的 `FALLBACK_AGENT_IDS`
+3. 无需改 API 层（`agent_names` 由推荐结果传入）
+
+### 12.2 调整 Step 1 澄清轮次上限
+
+逻辑在 agent SOUL，不在前端；前端只需处理任意轮 `asking` / `clarification` / `done`。
+
+### 12.3 调整 Step 2 编排上限
+
+`RoundtablePlanningPage.tsx` 内 `MAX_CYCLES = 8`，超出会 toast「⏱️ 已达到最大研讨轮次,自动停止以避免循环」。若放宽：注意 `step2RoundtableDialogues` 数组会线性增长，超长讨论需要考虑虚拟滚动。
+
+### 12.4 把 special 改回并行
+
+不推荐；若一定要做：
+
+- 把 `for ... of leaderRes.dispatched` 改成 `await Promise.all(leaderRes.dispatched.map(...))`
+- 评估浏览器性能：每 token 一次 `setStep2RoundtableDialogues(prev => prev.map(...))`，N=6 时实测明显掉帧
+- 用更高效的派发结构（如按 id 分桶 `Map<id, Bubble>` + ref 缓存）改善之后再启用
+
+### 12.5 接入真实 Persona 覆盖
+
+当前 prompt / temp 只在前端记录；要落地需：
+
+- 后端开放 per-agent override 接口或在 `streamMultiAgent` 新增 `prompt_override` / `temperature` 字段
+- 前端：`agentConfigs[meta.speakerId]` 一并传入
+
+### 12.6 拆分页面（已完成 · 2026-05）
+
+主页面早期是 4 000+ 行单文件,2026-05 重构按"hooks 抽逻辑、components 抽 UI"原则拆分:
+
+- `hooks/useStep1Intent.ts` —— Step 1 全部状态机、init effect、INTENT_READY 同步
+- `hooks/useStep2Orchestration.ts` —— Step 2 状态、编排循环、对话流、Persona、澄清
+- `hooks/useDraftPersistence.ts` —— 草稿自动保存 / 手动保存 / 加载 / 重命名 / 删除
+- `components/Step{1,2,3}Panel.tsx` —— 纯 UI,只接收 props,不持有业务状态
+- `components/PersonaDrawer.tsx` —— Persona 抽屉
+- `components/Avatars.tsx` —— 所有 SVG 头像 + getAvatar
+- `lib/roundtable-constants.ts` —— 常量、类型、纯工具函数(buildRoleTemplates 等)
+- `lib/step-display.tsx` —— ChainOfThought 折叠卡的图标 + 文案 + 子节点渲染
+
+**主页面只保留**:顶栏(StepNavigation / HistoryDropdown)、左右两侧栏(LeftSidebar / RightSidebar)、步骤路由、推荐弹窗,以及编排 hook 与跨步 handler(`handleConfirmAgents` / `handleStartNewTask`)。
+
+继续重构请遵守:
+
+1. **不要在 Panel 组件里写 fetch / setState 业务流程** —— Panel 只渲染,事件透传到 hook。
+2. **hook 之间不要互相 import** —— 跨 hook 的数据通过主页面的 ref / callback 桥接(参考 `buildInitialIntent` 与 `loadedFromDraftRef` 的实现)。
+3. **草稿 snapshot 形状**(Step 1 的 `Step1Snapshot` / Step 2 的 `Step2Snapshot`)与 `api/drafts.ts` 的 `DraftStep{1,2}Snapshot` 是同一份语义,改字段时两边都要改;后端以 JSON 整存,不强约束嵌套字段。
+4. **lint/typecheck**:重构后 `pnpm typecheck` 与 `pnpm build` 必须保持 0 个新增错误(预存量错误来自其它无关模块如 `strategy-components` / `next/link` shim,与本特性无关)。
+
+### 12.7 文档协同
+
+`@/roundtable-planning/` 内一切公共 API 都应当：
+
+1. 在 `api/*.ts` 文件级注释里说明 endpoint
+2. 在本页第 4 节 / 第 10 节同步对照
+3. 后端字段变化（如 `init_done` 字段名）需要同步改 `initMultiAgent` 解析逻辑 + `multi-agent-api.md`
+
+---
+
+## 13. 路径速查
+
+| 资源 | 路径 |
+|------|------|
+| 主页面（组合 + 顶栏 + 侧栏） | `frontend-web/src/roundtable-planning/pages/RoundtablePlanningPage.tsx` |
+| Step 1 hook | `frontend-web/src/roundtable-planning/hooks/useStep1Intent.ts` |
+| Step 2 hook(含编排循环) | `frontend-web/src/roundtable-planning/hooks/useStep2Orchestration.ts` |
+| 草稿 hook | `frontend-web/src/roundtable-planning/hooks/useDraftPersistence.ts` |
+| Step 1 面板 | `frontend-web/src/roundtable-planning/components/Step1Panel.tsx` |
+| Step 2 面板 | `frontend-web/src/roundtable-planning/components/Step2Panel.tsx` |
+| Step 3 面板 | `frontend-web/src/roundtable-planning/components/Step3Panel.tsx` |
+| 消息气泡共享件 | `frontend-web/src/roundtable-planning/components/MessageBubble.tsx` |
+| 步骤折叠卡(工具/思考) | `frontend-web/src/roundtable-planning/components/MessageStepsCard.tsx` |
+| `<think>` 提取工具 | `frontend-web/src/roundtable-planning/lib/reasoning.ts` |
+| Persona 抽屉 | `frontend-web/src/roundtable-planning/components/PersonaDrawer.tsx` |
+| 头像集合 | `frontend-web/src/roundtable-planning/components/Avatars.tsx` |
+| 常量/工具函数 | `frontend-web/src/roundtable-planning/lib/roundtable-constants.ts` |
+| ChainOfThought 渲染 | `frontend-web/src/roundtable-planning/lib/step-display.tsx` |
+| Step 1 API | `frontend-web/src/roundtable-planning/api/intent.ts` |
+| 推荐 API（含推荐历史） | `frontend-web/src/roundtable-planning/api/recommend.ts` |
+| 草稿 API（后端 CRUD） | `frontend-web/src/roundtable-planning/api/drafts.ts` |
+| Step 2/3 API | `frontend-web/src/roundtable-planning/api/multi-agent.ts` |
+| 澄清卡片 | `frontend-web/src/roundtable-planning/components/IntentClarificationCard.tsx` |
+| 推荐弹窗 | `frontend-web/src/roundtable-planning/components/RecommendAgentsDialog.tsx` |
+| Step 3 报告 | `frontend-web/src/roundtable-planning/components/HighFidelityReport.tsx` |
+| 文件预览 | `frontend-web/src/roundtable-planning/components/ArtifactPreviewModal.tsx` |
+| 回底按钮 | `frontend-web/src/roundtable-planning/components/ScrollToBottomButton.tsx` |
+| 滚动跟随 | `frontend-web/src/roundtable-planning/hooks/useAutoScroll.ts` |
+| 澄清单选逻辑 | `frontend-web/src/roundtable-planning/lib/clarification.ts` |
+| 后端草稿/历史路由 | `offline-backend-20260512/backend/app/gateway/routers/roundtable_drafts.py` |
+| 路由 | `frontend-web/src/pages/WorkspaceRoutes.tsx` |
+| 样式 | `frontend-web/src/roundtable-planning/styles/roundtable-planning.css` |
+| 主聊天澄清参考 | `frontend-web/src/components/workspace/messages/message-list.tsx` |
+| 后端开发文档 | `frontend-web/docs/multi-agent-backend-dev.md` |
+| API 速查 | `frontend-web/docs/multi-agent-api.md` |

frontend-web/docs/multi-agent-step2-run-branches.md

@@ -0,0 +1,404 @@
+# 多智能体会商 Step2 多结果线方案
+
+## 背景
+
+当前「多智能体会商 / 多智能体规划」里，一个历史草稿只保存一份 `step2` 快照。用户从历史记录加载草稿后，如果再次点击「智能体推荐」并在弹窗里点击「进入研讨」，新的 Step2 研讨会继续写入同一份 `draft.step2`，结果是第一次生成内容会被第二次生成内容覆盖，或者页面只能展示最新一次结果。
+
+产品期望是：
+
+- 用户从历史记录进入已有草稿时，进入第二步后，左下角能看到第一次生成结果。
+- 用户再次点击「智能体推荐」并点击「进入研讨」时，要开启一条新的研讨结果线。
+- 第二次生成结果显示在左下角，但不能影响第一次生成结果。
+- 用户之后再次查看同一个历史草稿时，可以分别查看第一次生成结果和第二次生成结果。
+
+因此，这个需求的核心不是简单增加一个展示区域，而是把 Step2 从「单结果」升级为「一个草稿下多条研讨 run」。
+
+## 现状
+
+相关位置：
+
+- `src/roundtable-planning/api/drafts.ts`
+- `src/roundtable-planning/pages/RoundtablePlanningPage.tsx`
+- `src/roundtable-planning/hooks/useStep2Orchestration.ts`
+- `src/roundtable-planning/components/Step2Panel.tsx`
+- `src/roundtable-planning/components/RecommendAgentsDialog.tsx`
+
+当前 `DraftStep2Snapshot` 结构大致是：
+
+```ts
+export interface DraftStep2Snapshot {
+  selectedAgents?: Array<{ agent_id: string; name: string }>;
+  threadIds: ThreadIdMap | null;
+  coordinatorName: string | null;
+  step2RoundtableDialogues: unknown[];
+  lastLeaderContent: string;
+  hasConsensus: boolean;
+  consensusPercentage: number;
+  budgetLimit: number;
+  seatStubMessages?: Record<string, unknown[]>;
+  orchestrationMode?: "recommend" | "chain";
+  chain?: { id: string; title: string } | null;
+}
+```
+
+这意味着一个草稿只有一份：
+
+- 参会智能体
+- 多智能体 thread 映射
+- 研讨气泡
+- 总控最终内容
+- 共识状态
+- 沙箱产物 stub
+- 编排模式和业务链条
+
+当前 `RoundtablePlanningPage.tsx` 里的 `handleConfirmAgents` 在用户点击「进入研讨」后会：
+
+1. 规范化选中的 agents。
+2. 写入 `step2.selectedAgents`。
+3. 调用 `step2.resetInitGate()`。
+4. 设置 `orchestrationMode` / `chainMeta`。
+5. 切到 `currentStep = 2`。
+
+它没有先把当前 Step2 结果归档成「第一次生成结果」，也没有为新的研讨创建独立 run。因此第二次研讨天然会复用同一个 `draft.step2` 写入位置。
+
+## 目标模型
+
+建议引入 Step2 run 概念：一个草稿可以有多条 Step2 结果线，每条结果线保存一份完整的 Step2 快照。
+
+```ts
+interface Step2RunSnapshot {
+  id: string;
+  title: string;
+  createdAt: string;
+  source: "initial" | "recommend" | "chain" | "manual";
+  selectedAgents?: Array<{ agent_id: string; name: string }>;
+  threadIds: ThreadIdMap | null;
+  coordinatorName: string | null;
+  step2RoundtableDialogues: unknown[];
+  lastLeaderContent: string;
+  hasConsensus: boolean;
+  consensusPercentage: number;
+  budgetLimit: number;
+  seatStubMessages?: Record<string, unknown[]>;
+  orchestrationMode?: "recommend" | "chain";
+  chain?: { id: string; title: string } | null;
+  step3?: DraftStep3Snapshot | null;
+}
+```
+
+`DraftStep2Snapshot` 保留现有字段作为当前激活 run 的镜像，同时新增 `runs` 和 `activeRunId`：
+
+```ts
+export interface DraftStep2Snapshot {
+  activeRunId?: string;
+  runs?: Step2RunSnapshot[];
+
+  selectedAgents?: Array<{ agent_id: string; name: string }>;
+  threadIds: ThreadIdMap | null;
+  coordinatorName: string | null;
+  step2RoundtableDialogues: unknown[];
+  lastLeaderContent: string;
+  hasConsensus: boolean;
+  consensusPercentage: number;
+  budgetLimit: number;
+  seatStubMessages?: Record<string, unknown[]>;
+  orchestrationMode?: "recommend" | "chain";
+  chain?: { id: string; title: string } | null;
+}
+```
+
+这样做的好处：
+
+- 老代码仍然可以从 `draft.step2.step2RoundtableDialogues` 读取当前结果。
+- 新 UI 可以从 `draft.step2.runs` 展示第一次、第二次、第三次生成结果。
+- 老草稿没有 `runs` 时，可以在 hydrate 时把原来的 `step2` 包装成一条默认 run。
+- 暂时不需要改数据库表结构，因为 `step2` 本身就是 JSON 快照。
+
+## 行为设计
+
+### 1. 历史记录加载
+
+用户点击历史记录加载草稿时：
+
+1. 拉取完整草稿。
+2. 如果 `draft.step2.runs` 存在，使用 `activeRunId` 找到当前结果线。
+3. 如果 `draft.step2.runs` 不存在，但旧字段里有 `step2RoundtableDialogues`，自动包装成一条 run：
+
+```ts
+{
+  id: "legacy-run",
+  title: "第一次生成结果",
+  createdAt: draft.updatedAt,
+  source: "initial",
+  ...draft.step2
+}
+```
+
+4. hydrate 当前 active run 到 Step2 runtime。
+5. 左下角展示 run 列表。
+
+### 2. 再次点击智能体推荐进入研讨
+
+用户在已有历史草稿中再次点击「智能体推荐」并确认进入研讨时：
+
+1. 先把当前页面里的 Step2 状态保存为当前 active run。
+2. 创建一条新的 run：
+
+```ts
+{
+  id: crypto.randomUUID(),
+  title: `第 ${runs.length + 1} 次生成结果`,
+  createdAt: new Date().toISOString(),
+  source: result.mode,
+  selectedAgents: normalizedAgents,
+  threadIds: null,
+  coordinatorName: null,
+  step2RoundtableDialogues: [],
+  lastLeaderContent: "",
+  hasConsensus: false,
+  consensusPercentage: 0,
+  budgetLimit: DEFAULT_BUDGET,
+  seatStubMessages: {},
+  orchestrationMode: result.mode,
+  chain: result.mode === "chain" ? result.chain ?? null : null
+}
+```
+
+3. 将 `activeRunId` 切到新 run。
+4. 清空 Step2 runtime。
+5. 设置新选中的 agents / mode / chain。
+6. `resetInitGate()`，进入 Step2 后重新创建一组独立 thread。
+7. 自动保存草稿。
+
+关键点：第二次 run 必须使用新的 `threadIds`，不能沿用第一次 run 的 `threadIds`，否则后端 thread 历史会混在一起。
+
+### 3. 左下角结果列表
+
+左下角建议展示一个「生成结果」区域：
+
+- 第一次生成结果
+- 第二次生成结果
+- 第三次生成结果
+
+每条展示：
+
+- 标题
+- 创建时间
+- 状态：研讨中 / 已达成共识 / 未完成 / 已生成报告
+- 使用模式：智能体推荐 / 业务链条
+
+点击某条结果时：
+
+1. 保存当前 active run。
+2. 切换 `activeRunId`。
+3. hydrate 被点击的 run。
+4. 中间 Step2 对话区显示该 run 的研讨气泡。
+5. 如果该 run 已有 `step3`，进入 Step3 时展示对应报告。
+
+### 4. Step3 结果归属
+
+目前 `draft.step3` 是草稿级别的一份报告。如果只保留这一份，第二次结果生成报告后仍会覆盖第一次报告。
+
+建议：
+
+- `draft.step3` 继续作为当前 active run 的镜像，兼容现有 Step3 页面。
+- 每条 `Step2RunSnapshot.step3` 保存自己的报告。
+- `onReportSaved` 时同时写入当前 active run 的 `step3`。
+
+这样用户切换到第一次生成结果时，可以看到第一次的 Step3 报告；切换到第二次生成结果时，可以看到第二次的 Step3 报告。
+
+## 建议改动点
+
+### 1. `api/drafts.ts`
+
+扩展类型：
+
+- 新增 `Step2RunSnapshot`。
+- `DraftStep2Snapshot` 增加 `activeRunId?: string` 和 `runs?: Step2RunSnapshot[]`。
+
+同时保留旧字段，避免影响现有保存、加载和 Step3。
+
+### 2. `useStep2Orchestration.ts`
+
+新增或暴露两个能力：
+
+- `getCurrentRunSnapshot()`：从当前 Step2 runtime 生成一条 run 快照。
+- `hydrateRunSnapshot(run)`：把某条 run 恢复到 Step2 runtime。
+
+`hydrateFromDraft` 继续存在，但内部可以优先选择 active run 来 hydrate。
+
+### 3. `RoundtablePlanningPage.tsx`
+
+新增页面级状态：
+
+```ts
+const [step2Runs, setStep2Runs] = useState<Step2RunSnapshot[]>([]);
+const [activeStep2RunId, setActiveStep2RunId] = useState<string | null>(null);
+```
+
+调整几个流程：
+
+- `getStep2Snapshot` 输出 `runs` 和 `activeRunId`。
+- `hydrateStep2` 兼容旧草稿并恢复 runs。
+- `handleConfirmAgents` 在新建研讨前先归档当前 active run，再创建新 run。
+- `onReportSaved` 把 Step3 报告写回当前 active run。
+
+### 4. `Step2Panel.tsx`
+
+新增左下角结果列表展示。建议作为一个独立组件，避免 Step2Panel 继续变大：
+
+```tsx
+<Step2RunSwitcher
+  runs={step2Runs}
+  activeRunId={activeStep2RunId}
+  onSelect={handleSelectStep2Run}
+/>
+```
+
+组件职责只做展示和选择，不直接读写 draft。
+
+### 5. `Step3Panel.tsx`
+
+传入当前 active run 的报告：
+
+- 如果当前 run 有 `step3`，展示它。
+- 如果没有，按现有逻辑生成新报告。
+- 生成完成后通过 `onReportSaved` 写回 run。
+
+## 兼容策略
+
+老草稿没有 `runs` 字段时，不做数据迁移，前端加载时即时包装。
+
+判断规则：
+
+```ts
+function normalizeStep2Runs(step2: DraftStep2Snapshot): {
+  runs: Step2RunSnapshot[];
+  activeRunId: string | null;
+} {
+  if (step2.runs?.length) {
+    return {
+      runs: step2.runs,
+      activeRunId: step2.activeRunId ?? step2.runs[0].id,
+    };
+  }
+
+  const hasLegacyContent =
+    step2.step2RoundtableDialogues?.length > 0 ||
+    Boolean(step2.threadIds) ||
+    Boolean(step2.lastLeaderContent);
+
+  if (!hasLegacyContent) {
+    return { runs: [], activeRunId: null };
+  }
+
+  const legacyRun: Step2RunSnapshot = {
+    id: "legacy-run",
+    title: "第一次生成结果",
+    createdAt: new Date().toISOString(),
+    source: step2.orchestrationMode ?? "initial",
+    selectedAgents: step2.selectedAgents,
+    threadIds: step2.threadIds,
+    coordinatorName: step2.coordinatorName,
+    step2RoundtableDialogues: step2.step2RoundtableDialogues,
+    lastLeaderContent: step2.lastLeaderContent,
+    hasConsensus: step2.hasConsensus,
+    consensusPercentage: step2.consensusPercentage,
+    budgetLimit: step2.budgetLimit,
+    seatStubMessages: step2.seatStubMessages,
+    orchestrationMode: step2.orchestrationMode,
+    chain: step2.chain,
+  };
+
+  return { runs: [legacyRun], activeRunId: legacyRun.id };
+}
+```
+
+## 风险点
+
+### 1. 自动保存覆盖
+
+Step2 现在会在每个气泡收尾时自动保存。如果引入多 run，自动保存必须先把当前 runtime 合并回 active run，再写入 `draft.step2.runs`。
+
+否则会出现 UI 切到第二次结果，但保存时仍更新第一次 run 的情况。
+
+### 2. threadIds 混用
+
+每条 run 必须拥有自己的 `threadIds`。新建 run 时要清空 `threadIds` 并让 Step2 重新 init。
+
+如果复用旧 thread，会导致两次研讨的后端上下文互相污染。
+
+### 3. Step3 报告覆盖
+
+如果只保存草稿级 `step3`，多 run 的报告无法分别查看。
+
+建议把报告写入当前 run，同时保留草稿级 `step3` 作为 active run 镜像。
+
+### 4. 正在运行中的 run
+
+如果配合后台任务能力，run 还需要带 job 信息：
+
+```ts
+jobId?: string | null;
+jobStatus?: JobStatus | null;
+```
+
+这样左下角可以显示「第二次生成结果正在运行」，并打开派活链路弹窗。
+
+## 分阶段实现建议
+
+### P0：纯前端多 run 快照
+
+目标：先解决“第一次 / 第二次结果分别可查看”。
+
+- 扩展 `DraftStep2Snapshot` 类型。
+- 页面维护 `step2Runs` / `activeStep2RunId`。
+- `handleConfirmAgents` 新建 run。
+- 左下角展示 run 列表。
+- 切换 run 能恢复不同 Step2 对话。
+
+不改后端表结构。
+
+### P1：Step3 绑定 run
+
+目标：每次研讨结果对应自己的报告。
+
+- `Step2RunSnapshot.step3` 保存报告。
+- `onReportSaved` 写回 active run。
+- 切换 run 时同步 Step3 显示。
+
+### P2：后台任务绑定 run
+
+目标：和后台挂起执行方案打通。
+
+- run 增加 `jobId` / `jobStatus`。
+- 历史列表和左下角都能显示某条 run 正在执行。
+- 点击正在执行的 run 打开派活链路弹窗。
+
+### P3：后端 run 表
+
+如果后续一个草稿下 run 数量很多，或者需要服务端按 run 查询、删除、重命名，再考虑新增后端表：
+
+- `roundtable_runs`
+- `draft_id`
+- `run_id`
+- `title`
+- `status`
+- `step2_snapshot`
+- `step3_snapshot`
+- `created_at`
+- `updated_at`
+
+短期不建议一开始就上表，先用现有 `step2` JSON 快照落地更快。
+
+## 验收清单
+
+- 从历史记录加载旧草稿时，左下角出现「第一次生成结果」。
+- 点击「第一次生成结果」能看到原来的 Step2 研讨气泡。
+- 在历史草稿中重新点击「智能体推荐」并「进入研讨」后，左下角新增「第二次生成结果」。
+- 第二次研讨开始时，Step2 对话区为空或只显示新 run 初始化内容。
+- 第二次 run 使用新的 `threadIds`，不会复用第一次 run 的后端线程。
+- 切回「第一次生成结果」时，第一次的对话、共识状态、沙箱产物仍可查看。
+- 切回「第二次生成结果」时，第二次的对话继续显示。
+- 刷新页面后再次加载该历史草稿，两条结果线都还在。
+- 如果两次都生成了 Step3 报告，切换不同结果线时能看到各自对应的报告。

frontend-web/docs/multi-agent-后台挂起续跑实现方案.md

@@ -0,0 +1,198 @@
+# 后台挂起「在当前进度继续」实现方案
+
+> 状态：**待实现**（仅方案，未改代码）
+> 关联：[[multi-agent-background-run-dev.md]]、[[multi-agent-frontend-dev.md]]、memory `project-roundtable-background`
+> 目标：点「后台挂起」后，后端作业**在前端当前研讨进度上接着跑**，而不是新建空线程从头重跑。
+
+---
+
+## 1. 现象与根因
+
+### 现象
+在第二步研讨进行中点「后台挂起」，转入后台的作业是**从头重新开始执行**（重新初始化席位、从原始 intent 重新派活），而不是接着前端已经讨论到的进度往下走。
+
+### 根因
+后端「起作业」路由 `start_job` **从不设 `is_resume`**（默认 `False`），而执行器据此**新建一套全新线程**：
+
+```python
+# offline-backend-20260512/backend/app/gateway/roundtable_job_executor.py  (_run, 约 215 行)
+init = getattr(gateway, "init_threads", None)
+if init is not None and not params.is_resume:
+    thread_ids, coordinator_name = await init()   # ← 建全新空线程
+```
+
+加上前端 `startBackgroundJob` **故意不传 `threadIds`**、用 `buildInitialIntent()` 作第一轮 leader prompt，于是后台作业 = 空线程 + 原始意图 = 从头重跑。
+
+> 这是**原设计的有意取舍**。`startBackgroundJob` 注释写明：不复用前端线程，因为「那些线程可能有活跃 run，复用会撞 409」。本方案就是要在可控前提下打开「复用前端线程续跑」这条路。
+
+### 后端其实已支持续跑
+澄清续跑路由 `resume_job`（`roundtable_jobs.py` 约 293 行）已经在做「在原线程上接着派活」：
+
+```python
+executor.start_job(StartParams(
+    ...,
+    seed_message=_RESUME_PREFIX + answer,        # 续跑式提示，而非原始 intent
+    thread_ids=row.get("thread_ids"),            # 复用作业自己的线程
+    coordinator_name=row.get("coordinator_name") or "roundtable-coordinator",
+    is_resume=True,                              # ← 关键：跳过 init_threads，直接复用
+    ...
+))
+```
+
+执行器在 `is_resume=True` 时直接用 `params.thread_ids` + `params.coordinator_name`（不调 `init_threads`），交给 `run_orchestration` 续跑。**所以能力已存在，`start_job` 只是没走这条路。**
+
+---
+
+## 2. 设计目标与关键事实
+
+- 「同进度续跑」= 后台作业复用**前端当前会话的真实线程**（总控 + 各席位），这些线程的 checkpoint 里已存着到目前为止的完整研讨上下文，续跑 = 在原线程上 post 一条「继续」消息让总控接着派活。
+- 前端编排是**逐轮**的：每轮一个 `POST /api/multi-agent/run/stream`（leader 或某席位），**轮与轮之间线程空闲**。只有「某一轮在飞时」线程才被占用。
+- 后端复用现成线程是**已验证路径**（`resume_job` 天天在用），唯一新增的不同点是：这次复用的是「前端会话线程」而非「上一个后台作业的线程」——但线程同属一个后端线程库，复用方式完全一致。
+
+---
+
+## 3. 改造点（最小集）
+
+### 3.1 后端：让 `start_job` 支持复用线程
+
+文件：`offline-backend-20260512/backend/app/gateway/routers/roundtable_jobs.py`
+
+1. `StartJobRequest` 增加字段：
+   ```python
+   resume: bool = False  # true + 携带 threadIds ⇒ 复用这些线程续跑，不新建
+   ```
+2. `start_job` 里把它透传给 `StartParams`：
+   ```python
+   is_resume = bool(body.resume and body.threadIds)
+   executor.start_job(StartParams(
+       ...,
+       thread_ids=body.threadIds,
+       coordinator_name=body.coordinatorName,
+       is_resume=is_resume,        # ← 新增
+       ...
+   ))
+   ```
+   其余执行器逻辑**不动**（它在 `is_resume=True` 时已能复用 `params.thread_ids`）。
+
+> 幂等闸门（同草稿未终态作业直接返回）保持不变；续跑挂起前前端应保证该草稿没有在跑的旧作业。
+
+### 3.2 前端 API：补 `resume` 入参
+
+文件：`frontend-web/src/roundtable-planning/lib/job-types.ts`
+- `StartJobPayload` 增加 `resume?: boolean`。
+
+文件：`frontend-web/src/roundtable-planning/api/roundtable-jobs.ts`
+- `toStartBody` 增加 `resume: p.resume ?? false`。
+
+### 3.3 前端：`startBackgroundJob` 改为复用线程续跑
+
+文件：`frontend-web/src/roundtable-planning/pages/RoundtablePlanningPage.tsx`（`startBackgroundJob` 约 1119 行）
+
+当前端已有现成会话（`step2.threadIds` 且 `step2.coordinatorName` 非空，说明研讨已 init）时，改传：
+
+```ts
+const canContinue = !!(step2.threadIds && step2.coordinatorName);
+await startJob({
+  draftId: draftId ?? undefined,
+  // 续跑：用「继续」式 seed，而不是 buildInitialIntent()（后者会让总控从头理解任务）
+  intent: buildInitialIntent(),                 // 仍传，作为无线程回退时的首轮 prompt
+  seedMessage: canContinue
+    ? "用户已将本次研讨转入后台，请基于现有进展继续上一轮的协调与派活；若已可收口则直接综合输出结论。"
+    : undefined,
+  agents,
+  model: selectedModel || undefined,
+  orchestrationMode,
+  chain: chainMeta,
+  orchestrationPlan: orchestrationMode === "dag" ? orchestrationPlan : null,
+  // 关键三件套：复用前端真实线程 + 协调名 + resume 标志
+  threadIds: canContinue ? step2.threadIds ?? undefined : undefined,
+  coordinatorName: canContinue ? step2.coordinatorName ?? undefined : undefined,
+  resume: canContinue,
+});
+```
+
+> 没有现成会话（极早期、线程未建）时 `canContinue=false`，自动回退到「新建线程 + 原 intent」的旧行为，安全。
+
+### 3.4 前端：挂起前先停本地编排（避免交出去时线程还在飞）
+
+文件：同上，`handleBackgroundSuspend`（约 1161 行）
+
+当前顺序是 `startBackgroundJob()` → `resetToStep1()`（reset 里才 `stopOrchestration`）。复用线程时必须**先停再交**：
+
+```ts
+const handleBackgroundSuspend = useCallback(async () => {
+  if (step2.selectedAgents.length === 0) { /* toast 提示后 return */ }
+  // 1. 先彻底停掉前端在飞的那一轮，尽量让线程在交给后台前变空闲
+  step2.stopOrchestration();
+  step2.setIsRoundTableRunning(false);
+  try {
+    // 2. 再起后台作业（复用线程续跑）
+    await startBackgroundJob();
+  } catch (err) { /* toast 失败后 return */ }
+  // 3. 最后重置回第一步（后台作业继续在历史记录里跑）
+  resetToStep1();
+  triggerToast("🚀 已转入后台，将基于当前进度继续研讨…");
+  void drafts.refresh();
+}, [...]);
+```
+
+---
+
+## 4. 关键风险：线程占用（409）与三种处理
+
+复用前端线程的唯一风险：**在某一轮在飞时挂起**，`stopOrchestration()` 只断了客户端 SSE，服务端那次 run 可能还在跑一小会儿；后台作业首轮 leader 向同一总控线程 post → 撞 409 / rollback。
+
+| 方案 | 做法 | 取舍 |
+|---|---|---|
+| **A（推荐起步）** | 仅前端 stop + 后端 `is_resume` 复用，接受小概率 409 | 实现最简，真正同进度续跑；轮间挂起 100% 安全，仅「某轮在飞时挂起」有小概率 409 —— 走编排循环**现有 rollback/重试容错**兜底 |
+| **B（最稳）** | 同 A，但后端在复用线程续跑前，**先 cancel 这些线程上可能残留的 run**（参考 takeover 里 `cancelJob` 的 `task.cancel()` 思路，落到 thread-run 级别）再 post | 几乎无 409；后端要多写「按 thread_id 取消活跃 run」的逻辑 |
+| **C（不推荐）** | 不复用线程，新建空线程，但把「目前为止的研讨」塞进 seed_message 让总控续写 | 零 409，但**席位子线程上下文全丢**、不是真正同进度、leader prompt 臃肿 |
+
+> 建议：先上 **A**，真机验证 409 命中率；若频繁再加 **B** 的后端线程级 cancel。
+
+---
+
+## 5. 适用范围（哪些挂起入口改续跑）
+
+三个触发源（见 `autoSuspendRef`）：
+
+1. **手动「后台挂起」按钮**（`handleBackgroundSuspend`）——**改续跑**。能在 start 前干净 stop，最适合复用线程。
+2. **路由卸载自动挂起**（切到其它页面，`fire`）——可改续跑（能走完整异步链）；卸载瞬间 stop 不一定彻底，按 A 方案的容错兜底。
+3. **刷新/关标签页 keepalive**（`beforeunload` 的 `beacon` → `startJobKeepalive`）——**建议保持新建线程**。关页时无法保证前端 run 已停，复用线程 409 风险最高；这里走「新建线程 + 原 intent」的安全回退即可（用户可在历史记录里点「查看」再用我们已实现的 takeover 接管回前端续跑）。
+
+> 落地顺序建议：先只改 #1，验证稳定后再决定是否推广到 #2。
+
+---
+
+## 6. 与已实现「查看=接管回前端」的关系
+
+二者是一对对称操作，复用同一套「线程同属一个后端库、可跨前后端续跑」的事实：
+
+- **后台挂起（本方案）**：前端 → 后端。前端 stop，把前端线程交给后台 `is_resume` 续跑。
+- **查看接管（已实现，见 memory）**：后端 → 前端。`cancelJob` 停后台，`hydrateFromDraft` 恢复作业真实线程，`resumeLiveTakeover()` 由前端在那些线程上续跑。
+
+实现本方案时可直接参照 takeover 的线程复用与 `is_resume` 经验。
+
+---
+
+## 7. 测试
+
+后端（`make test`）：
+- 新增/扩展 `tests/test_roundtable_jobs.py`：`start_job` 带 `resume=true + threadIds` ⇒ `StartParams.is_resume=True` 且**不调** `init_threads`、直接用传入线程；`resume=false` 或无 `threadIds` ⇒ 走 `init_threads` 新建（回归旧行为）。
+- 回归：`tests/test_roundtable_inprocess_request.py`、`tests/test_roundtable_step3_pipeline.py`（确认续跑不破坏 Step3 双产物）。
+
+前端（`pnpm typecheck`）+ 真机：
+- 研讨进行到几轮后点「后台挂起」→ 历史记录里点「查看」→ 确认后台是**接着已有对话**往下派活，而非从第 1 轮重来。
+- 轮间挂起 / 某轮在飞时挂起两种时机各验一次，观察是否出现 409（A 方案下应被 rollback 容错吸收）。
+
+---
+
+## 8. 落地清单（TL;DR）
+
+- [ ] 后端 `StartJobRequest.resume` 字段 + `start_job` 透传 `is_resume`
+- [ ] 前端 `StartJobPayload.resume` + `toStartBody`
+- [ ] 前端 `startBackgroundJob`：有会话时传 `threadIds/coordinatorName/seedMessage/resume`
+- [ ] 前端 `handleBackgroundSuspend`：调整为 **先 stop 再 start 再 reset**
+- [ ] 后端测试（resume 复用 vs 新建分支）
+- [ ] 真机验证「接着进度跑」+ 409 命中率
+- [ ]（可选）方案 B：后端复用线程前按 thread_id 取消残留 run

frontend-web/docs/openCanvas-progress.md

@@ -1,312 +0,0 @@
-# Open Canvas 集成进度文档
-
-> 最后更新：2026-05-16
-> 当前分支：dhk-1
-
----
-
-## 一、整体进度概览
-
-### Canvas 系统（双栏写作/编码工作区）
-
-| 阶段 | 名称 | 状态 |
-|------|------|------|
-| 阶段一 | 前端路由与目录骨架 | ✅ 已完成 |
-| 阶段二 | Canvas 双栏布局 | ✅ 已完成 |
-| 阶段三 | 前端 artifact 类型定义 | ✅ 已完成 |
-| 阶段四 | 后端 ThreadState 扩展 | ✅ 已完成 |
-| 阶段五 | canvas_agent 注册 + 最小节点闭环 | ✅ 已完成 |
-| 阶段六 | 前后端流式同步 | ✅ 已完成 |
-| 阶段七 | 版本历史导航 | ✅ 已完成 |
-| 阶段八 | 局部选区改写（Writing Editor 级） | ✅ 已完成 |
-| 阶段九 | 快捷动作系统 | ✅ 已完成 |
-| 阶段十 | 本地模型选择支持 | ✅ 已完成 |
-
-### AI Writing Editor（文本 artifact 编辑器内置 AI 改写）
-
-| 步骤 | 名称 | 状态 |
-|------|------|------|
-| Step 1 | Tiptap 编辑器核心 | ✅ 已完成 |
-| Step 2 | 写作工具栏 + 模型选择器 | ✅ 已完成 |
-| Step 3a | 气泡菜单（选区 AI 改写入口） | ✅ 已完成 |
-| Step 3b | 段落悬停按钮（整段 AI 改写入口） | ✅ 已完成 |
-| Step 4 | AI 改写菜单 + SSE 流式接口 | ✅ 已完成 |
-| Step 5 | 候选结果预览 + 替换/插入 | ✅ 已完成 |
-| Step 6 | 后端 `POST /api/writing/rewrite`（SSE，思考分离） | ✅ 已完成 |
-| Step 7 | 视觉精修（字体、间距、排版） | ✅ 已完成 |
-
-**当前状态：全部功能已完成 🎉**
-
----
-
-## 二、已完成工作详情
-
-### 2.1 前端核心文件结构
-
-```
-frontend-web/src/open-canvas/
-├── api/
-│   ├── client.ts          # LangGraph SDK 客户端实例
-│   ├── models.ts          # 模型列表 API
-│   ├── rewrite.ts         # AI 改写 SSE 流（streamRewrite，parseSse）
-│   ├── runs.ts            # streamCanvasRun（老的直接 API，已停用）
-│   └── threads.ts         # createCanvasThread、getCanvasThread
-├── components/
-│   ├── artifact/
-│   │   ├── CanvasArtifactHeader.tsx      # 右栏顶部：标题、语言、版本导航
-│   │   ├── CanvasArtifactPanel.tsx       # 右栏：流式预览 / 编辑器 / 空状态
-│   │   ├── CanvasArtifactVersionNav.tsx  # prev/next 版本切换
-│   │   ├── CanvasEmptyState.tsx          # 5 种快速开始模板
-│   │   ├── CanvasQuickActionBar.tsx      # 快捷动作按钮栏
-│   │   ├── CodeArtifactRenderer.tsx      # CodeMirror 代码编辑器
-│   │   ├── TextArtifactRenderer.tsx      # Tiptap 文本编辑器 + AI 改写流程
-│   │   ├── WritingAiMenu.tsx             # AI 改写动作菜单（polish/expand/shorten/tone）
-│   │   ├── WritingBubbleMenu.tsx         # 选区气泡菜单（portal 实现）
-│   │   ├── WritingParagraphMenu.tsx      # 段落悬停 AI 改写按钮
-│   │   ├── WritingRewritePreview.tsx     # 改写结果预览面板（含思考过程展开）
-│   │   └── WritingToolbar.tsx            # 格式工具栏（含模型选择器）
-│   ├── chat/
-│   │   └── CanvasChatPanel.tsx           # 左栏：消息列表 + 输入框
-│   ├── layout/
-│   │   ├── CanvasHeader.tsx              # 顶部栏：返回、折叠、流式指示
-│   │   ├── CanvasResizableLayout.tsx     # 左右可拖拽双栏（含 CanvasStreamProvider）
-│   │   └── CanvasShell.tsx               # 顶层壳：加载已有线程状态
-│   └── selectors/
-│       └── CanvasModelSelector.tsx       # 模型下拉选择器
-├── contexts/
-│   ├── CanvasGraphContext.tsx   # artifact、streamingArtifact、isStreaming
-│   ├── CanvasStreamContext.tsx  # 共享 useCanvasThreadStream 实例（sendMessage）
-│   ├── CanvasThreadContext.tsx  # threadId、modelName
-│   └── CanvasUIContext.tsx      # isChatCollapsed、writingSelection
-├── editor/
-│   ├── TiptapEditor.tsx         # EditorContent 包装器
-│   └── TiptapExtensions.ts      # StarterKit + Underline + Placeholder + Markdown
-├── hooks/
-│   ├── useCanvasArtifact.ts     # artifact 初始化工具
-│   ├── useCanvasQuickActions.ts # 快捷动作触发（走 CanvasStreamContext）
-│   ├── useCanvasSelection.ts    # 文字/代码选区状态
-│   ├── useCanvasStream.ts       # 旧直接 API 流（已停用，保留备用）
-│   ├── useCanvasThread.ts       # 线程加载工具
-│   ├── useCanvasThreadStream.ts # LangGraph SDK useStream hook（主流）
-│   ├── useWritingEditor.ts      # Tiptap editor 实例管理
-│   └── useWritingRewrite.ts     # AI 改写状态机（ThinkTagParser、AbortController）
-├── pages/
-│   ├── CanvasHomePage.tsx       # 欢迎页 + 快速开始
-│   └── CanvasThreadPage.tsx     # Provider 装配层
-├── routes/
-│   └── OpenCanvasRoutes.tsx     # /page/canvas/* 子路由
-├── types/
-│   ├── artifact.ts              # CanvasArtifact、CanvasArtifactText、CanvasArtifactCode
-│   ├── model.ts                 # CanvasModel
-│   ├── quick-action.ts          # QuickAction、QuickActionId
-│   ├── selection.ts             # CanvasTextSelection、CanvasCodeSelection
-│   └── thread.ts                # CanvasMessage、CanvasThreadValues
-└── utils/
-    ├── apply-rewrite.ts         # applyReplace、applyInsert（Tiptap 事务）
-    ├── artifact.ts              # getCurrentArtifactContent、setCurrentArtifactIndex 等
-    ├── quick-actions.ts         # buildQuickActionMessage（含 artifact 内容注入）
-    ├── selection.ts             # buildMessageWithSelection
-    ├── stream.ts                # 流式工具
-    └── thread.ts                # 线程工具
-```
-
-### 2.2 后端核心文件结构
-
-```
-offline-backend-20260512/backend/
-├── packages/harness/deerflow/agents/
-│   ├── canvas_agent/
-│   │   ├── __init__.py
-│   │   ├── agent.py      # make_canvas_agent()：LangGraph graph 工厂
-│   │   ├── prompt.py     # build_canvas_system_prompt()：含 selection_rewrite + quick_actions
-│   │   └── tools.py      # update_artifact_tool：创建/追加 artifact 版本
-│   └── thread_state.py   # ThreadState（含 artifact 字段、CanvasArtifact TypedDict）
-└── app/gateway/
-    ├── app.py            # 注册 writing router
-    └── routers/
-        └── writing.py    # POST /api/writing/rewrite（SSE 流式）
-```
-
-**langgraph.json** 注册了两个 graph：
-- `lead_agent` → 主聊天 Agent
-- `canvas_agent` → Canvas 写作 Agent
-
-### 2.3 关键 Context 层级
-
-```
-CanvasThreadPage
-  ├── CanvasThreadProvider      # threadId、modelName
-  │     ├── CanvasGraphProvider # artifact、streamingArtifact、isStreaming
-  │     │     └── CanvasUIProvider  # isChatCollapsed、writingSelection
-  │     │           └── CanvasShell
-  │     │                 └── CanvasResizableLayout
-  │     │                       └── CanvasStreamProvider  ← 持有 useCanvasThreadStream 单例
-  │     │                             ├── CanvasChatPanel      # 读 useCanvasStreamContext()
-  │     │                             └── CanvasArtifactPanel
-  │     │                                   └── CanvasQuickActionBar  # 读 useCanvasStreamContext()
-```
-
----
-
-## 三、关键架构决策与注意事项
-
-### 3.1 流式架构：单例流（重要）
-
-**问题**：原先 `CanvasChatPanel` 调 `useCanvasThreadStream()`，`CanvasQuickActionBar` 调 `useCanvasStream()`（旧的直接 API），两套流互不相通，快捷动作响应不出现在聊天面板。
-
-**解决方案**：新增 `CanvasStreamContext`，在 `CanvasResizableLayout` 中调用 `useCanvasThreadStream()` 一次，通过 Context 共享给所有子组件。`CanvasChatPanel` 和 `useCanvasQuickActions` 都从 `useCanvasStreamContext()` 取 `sendMessage`。
-
-```
-useCanvasStream（旧，已停用） ← 不再被调用，保留备用
-useCanvasThreadStream（新，LangGraph SDK） ← 通过 CanvasStreamContext 统一共享
-```
-
-### 3.2 artifact 内容注入机制（重要）
-
-**问题**：LangGraph `create_agent` 只把 `state.messages` 传给 LLM，`state.artifact` 字段不会自动可见。Agent 做 expand/shorten 等操作时看不到要改写的内容。
-
-**解决方案**：在每次 `sendMessage` 时，把当前 artifact 内容以 `<artifact>` 标签嵌入人类消息末尾。
-
-- 普通聊天：`sendMessage` 内部自动追加（仅当消息里还没有 `<artifact>` 时）
-- 快捷动作：`buildQuickActionMessage(id, content)` 在构建时就包含内容
-- 聊天面板显示时：`message-list-item.tsx` 调 `stripArtifactTag()` 剥掉标签，用户看不到
-
-```typescript
-// utils/quick-actions.ts
-export function buildQuickActionMessage(id, content) {
-  const body = isCodeArtifact(content) ? content.code : content.fullMarkdown;
-  return `${instruction}\n\n<artifact ${tag}>\n${body}\n</artifact>`;
-}
-
-// core/messages/utils.ts
-export function stripArtifactTag(content: string): string {
-  return content.replace(/<artifact[^>]*>[\s\S]*?<\/artifact>/g, "").trim();
-}
-```
-
-### 3.3 ThinkTagParser（AI 改写思考过程解析）
-
-后端支持两种思考格式：
-- Anthropic：独立 thinking block，以 `event: thinking` SSE 事件传输
-- DeepSeek：把思考过程内联在文本里：`<think>...</think>content`
-
-前端 `useWritingRewrite.ts` 的 `ThinkTagParser` 是流式状态机，处理跨 chunk 边界的 `<think>` 标签。
-
-### 3.4 版本历史：本地切换
-
-`CanvasArtifactVersionNav` 的 prev/next 只修改本地 `CanvasGraphContext.artifact.currentIndex`，不写回后端。刷新后 currentIndex 重置为后端存储的最新值（这是有意的简化设计）。
-
-### 3.5 Writing Editor 流程（三阶段状态机）
-
-```
-idle → menu → preview → idle
-         ↑              ↓
-     openAiMenu      closeAll
-```
-
-- **idle**：正常编辑
-- **menu**：显示 `WritingAiMenu`（选择 polish/expand/shorten/tone）
-- **preview**：显示 `WritingRewritePreview`（SSE 流式结果 + 思考过程 + 替换/插入按钮）
-
----
-
-## 四、已解决的技术难题
-
-| 问题 | 解法 |
-|------|------|
-| react-resizable-panels v4 API 变更（`orientation` 不是 `direction`，`groupRef` 不是 `ref`，`setLayout` 参数为 `{id: size}` 对象） | 参考 v4 文档，逐一修正 |
-| Flex 高度链底部裁剪 | 在 wrapper div 加 `min-h-0`，配合 `flex-1 overflow-hidden` |
-| Tiptap v3 BubbleMenu 已从 React 组件改为纯 Extension | 自定义 portal 实现：监听 `selectionUpdate`，手动计算位置 |
-| 段落悬停按钮鼠标桥接：鼠标经过 6px 间隙时按钮消失 | 文档级 `mousemove` 监听 + 380ms 延迟隐藏，判断鼠标是否在扩展热区内 |
-| 弹窗超出屏幕底部 | 检测 `spaceBelow` vs `spaceAbove`，空间不足时翻转到光标上方 |
-| DeepSeek 在文本流里混入 `<think>` 标签 | `ThinkTagParser` 状态机，保留最后 6/7 字节防止跨 chunk 分割 |
-| loading→success 状态转换检测（stale closure） | 用 `prevStatusRef` + `useEffect` 检测 status 变化，取代直接读 state |
-| 快捷动作响应不出现在聊天面板 | `CanvasStreamContext` 统一 `sendMessage` 入口 |
-| LLM 看不到 artifact 内容（只有 state.messages） | 消息里直接嵌入 `<artifact>` 标签，显示时剥离 |
-| `<artifact>` 标签在聊天面板里显示 | `message-list-item.tsx` 调 `stripArtifactTag()` |
-
----
-
-## 五、当前已知限制（非 bug，设计取舍）
-
-1. **版本切换不持久化**：切换 artifact 版本后刷新页面会回到最新版本
-2. **useCanvasStream 孤立**：旧的直接 API 流 hook 保留但未被调用，可后续清理
-3. **CanvasShell 的 setMessages 冗余**：加载旧线程时 `setMessages` 写入 CanvasGraphContext，但 `CanvasChatPanel` 读的是 `thread.messages`（来自 useStream + fetchStateHistory）。setArtifact 仍有效
-4. **artifact 内容随消息发送**：大文档每条消息都附带全文，token 消耗较大。当前规模可接受
-
----
-
-## 六、快速开始下一次工作
-
-### 启动服务
-
-```bash
-# 后端（从 offline-backend-20260512/backend/）
-make dev       # 启动 Gateway API on port 8001
-
-# 前端（从 frontend-web/）
-pnpm dev       # 启动 Vite on port 5174
-```
-
-### 访问路径
-
-- 主页：`http://localhost:5174`
-- Canvas 入口：点击左侧导航 → Canvas，或直接访问 `http://localhost:5174/page/canvas`
-
-### 类型检查
-
-```bash
-cd frontend-web && pnpm typecheck
-# 预期：只有 CodeArtifactRenderer.tsx 的 CodeMirror 版本冲突错误（预存 bug，不影响运行）
-```
-
----
-
-## 七、如需继续开发的潜在方向
-
-| 方向 | 描述 | 优先级 |
-|------|------|------|
-| 版本切换持久化 | 将 currentIndex 变更写回后端 ThreadState | 低 |
-| artifact 内容 token 优化 | 仅发送 diff 或用 summary 代替全文 | 低 |
-| 清理 useCanvasStream | 删除未被调用的旧 hook | 低 |
-| 代码 artifact 的 AI 改写 | CodeArtifactRenderer 也接入 WritingAiMenu 流程 | 中 |
-| Canvas 选区→聊天（高级） | 用户在右栏选中文字后在左栏输入指令，自动带选区上下文 | 中 |
-| Tiptap 扩展（表格、任务列表） | 增加 Table、TaskList extension | 低 |
-
----
-
-## 八、关键文件速查
-
-| 文件 | 说明 |
-|------|------|
-| `frontend-web/docs/openCanvas-progress.md` | **本文档** |
-| `frontend-web/src/open-canvas/contexts/CanvasStreamContext.tsx` | 流单例 Context |
-| `frontend-web/src/open-canvas/hooks/useCanvasThreadStream.ts` | 主流 hook（LangGraph SDK） |
-| `frontend-web/src/open-canvas/hooks/useWritingRewrite.ts` | AI 改写状态机 |
-| `frontend-web/src/open-canvas/api/rewrite.ts` | 改写 SSE 客户端 |
-| `frontend-web/src/open-canvas/utils/quick-actions.ts` | 快捷动作消息构建 |
-| `frontend-web/src/core/messages/utils.ts` | `stripArtifactTag` 在此 |
-| `frontend-web/src/components/workspace/messages/message-list-item.tsx` | 调用 stripArtifactTag 的位置 |
-| `frontend-web/src/styles/globals.css` | Tiptap 写作编辑器样式（`.tiptap-writing-editor`） |
-| `offline-backend-20260512/backend/packages/harness/deerflow/agents/canvas_agent/agent.py` | canvas_agent 工厂 |
-| `offline-backend-20260512/backend/packages/harness/deerflow/agents/canvas_agent/tools.py` | update_artifact_tool |
-| `offline-backend-20260512/backend/packages/harness/deerflow/agents/canvas_agent/prompt.py` | 系统提示词 |
-| `offline-backend-20260512/backend/app/gateway/routers/writing.py` | AI 改写后端接口 |
-| `offline-backend-20260512/backend/langgraph.json` | canvas_agent 注册 |
-
----
-
-## 九、开始新对话的推荐提示词
-
-```
-我们在开发 DeerFlow 的 Canvas 写作模式（open-canvas 集成）。
-详细进度见：frontend-web/docs/openCanvas-progress.md
-
-当前全部功能已完成，包括：
-- Canvas 双栏布局、canvas_agent、版本历史
-- AI Writing Editor（Tiptap + SSE 改写 + 思考过程展开）
-- 快捷动作（通过 CanvasStreamContext 统一流）
-- artifact 内容注入（消息里嵌入 <artifact> 标签，显示时剥离）
-
-请根据进度文档第七节"潜在开发方向"或我指定的任务继续开发。
-```

frontend-web/docs/openCanvas.md

@@ -1,950 +0,0 @@
-# Open Canvas 模式需求拆解文档
-
-## 1. 文档目标
-
-本文档用于指导 DeerFlow 在现有架构中新增一个 `open-canvas` 风格的 Canvas 模式。
-
-目标不是直接照搬 `langchain-ai/open-canvas` 的 Next.js + LangGraph.js 实现，而是在当前项目技术栈内完成一套等价能力的实现：
-
-- 前端：基于 `React 19 + Vite + react-router-dom`
-- 后端：基于 `Python + FastAPI + LangGraph`
-- 模型层：支持云模型与本地模型自由配置
-- 状态层：支持结构化 artifact、版本历史、局部改写、快速动作、画布编辑
-
-本文档重点是把需求拆成“可实现、可排期、可验收”的阶段性任务。
-
----
-
-## 2. 最终目标
-
-### 2.1 用户视角目标
-
-用户进入一个新的 Canvas 工作模式后，可以获得与 open-canvas 接近的体验：
-
-- 左侧是聊天区，右侧是 Canvas 编辑区
-- 可以从空白文本或代码模板快速开始
-- 可以通过聊天让 AI 生成一份结构化 artifact
-- 可以对 artifact 整体重写，也可以对选中的局部内容进行改写
-- artifact 支持版本历史切换
-- artifact 支持文本和代码两种主要类型
-- 支持快速动作，例如扩写、压缩、改风格、改语气、加注释、修 bug、换语言
-- 支持启用 Web 搜索增强
-- 支持切换模型
-- 支持使用本地模型，例如 Ollama 或 OpenAI-compatible 本地服务
-
-### 2.2 工程视角目标
-
-新增的 Canvas 模式需要满足以下工程原则：
-
-- 不破坏现有 DeerFlow 工作区
-- 不影响现有基于 `artifacts: string[]` 的文件产物功能
-- 可逐阶段上线
-- 前后端状态协议清晰
-- 可兼容现有 LangGraph 线程、消息流、认证和模型接口
-
----
-
-## 3. 范围定义
-
-### 3.1 本次需求包含
-
-- 前端新增 `open-canvas` 专用目录
-- 在 [PageRoutes.tsx](../src/pages/PageRoutes.tsx) 中引入新的 Canvas 路由
-- 前端新增 Canvas 页面、上下文、组件、状态管理
-- 后端新增 Canvas 专用线程状态字段
-- 后端新增 Canvas Agent 图或在现有 Agent 体系中新增 Canvas 模式分支
-- 模型配置统一为 DeerFlow 后端配置驱动
-- 支持本地大模型配置与模型列表动态下发
-- 支持结构化 artifact 的保存、读取、更新、版本切换
-
-### 3.2 本次需求不包含
-
-- 一次性复刻 open-canvas 全部 UI 细节
-- 完整照搬 Supabase 鉴权体系
-- 直接复用 open-canvas 的 Next.js API Route
-- 直接运行 open-canvas 的 LangGraph.js 后端
-- 首阶段就实现所有快捷动作、所有富文本效果、所有搜索增强能力
-
-### 3.3 迁移原则
-
-- 借鉴 open-canvas 的能力模型，不直接迁移其运行时架构
-- 前端尽量复用其交互设计和数据结构
-- 后端以 Python 实现同等能力
-- 配置以 DeerFlow 为真源，不以 open-canvas 的 TS 文件为真源
-
----
-
-## 4. 总体设计思路
-
-### 4.1 前端设计思路
-
-在现有 `frontend-web/src` 下新增一个专用目录，例如：
-
-```text
-src/
-  open-canvas/
-    pages/
-    routes/
-    components/
-    contexts/
-    hooks/
-    types/
-    api/
-    utils/
-    constants/
-```
-
-建议将 Canvas 模式作为一个独立的页面子系统接入，而不是把现有工作区页面强行改造成 Canvas。
-
-建议路由形式：
-
-- `/canvas`
-- `/canvas/:threadId`
-
-也可以挂在现有页面布局下，例如：
-
-- `/workspace/canvas`
-- `/workspace/canvas/:threadId`
-
-推荐优先采用独立一级功能路由：
-
-- 逻辑更清晰
-- 状态隔离更容易
-- 不容易污染现有 `workspace` 功能
-
-### 4.2 后端设计思路
-
-后端不建议直接改造现有通用 Agent 去同时承担全部 Canvas 行为，而是建议采用以下两种方案之一：
-
-#### 方案 A：新增独立 Canvas Assistant
-
-- 新增 `canvas_agent`
-- 使用单独的 LangGraph 状态定义
-- 前端调用时通过 `assistant_id=canvas_agent`
-
-优点：
-
-- 与现有 `lead_agent` 隔离
-- 风险更低
-- 更容易对齐 open-canvas 的图结构
-
-缺点：
-
-- 会产生一套新的 Agent 图维护成本
-
-#### 方案 B：在现有 Lead Agent 中增加 Canvas 模式分支
-
-- 在 thread metadata 或 configurable 中增加 `ui_mode=canvas`
-- Agent 根据模式进入 Canvas 路径
-
-优点：
-
-- 统一入口
-
-缺点：
-
-- 会显著增加现有 Agent 复杂度
-- 容易影响现有聊天和文件产物模式
-
-推荐先做方案 A。
-
-### 4.3 模型配置设计思路
-
-模型配置统一以 DeerFlow 后端 `config.yaml` 为真源。
-
-前端不维护固定模型常量列表，而是通过 `/api/models` 获取模型能力元数据。
-
-为了实现 open-canvas 风格体验，需要后端模型接口至少返回：
-
-- `name`
-- `display_name`
-- `provider`
-- `supports_thinking`
-- `supports_reasoning_effort`
-- `supports_vision`
-- `supports_tool_calling`
-- `supports_artifact_editing`
-- `supports_code_editing`
-- `temperature_range`
-- `max_tokens_range`
-- `base_url_source` 或 provider 标识
-- `is_local`
-
----
-
-## 5. 与当前项目的关键差异
-
-### 5.1 当前 DeerFlow 现状
-
-当前 DeerFlow 线程状态中的 artifact 主要是文件路径列表：
-
-- `artifacts: string[]`
-
-这更接近“生成文件产物”的工作模式。
-
-前端当前 artifact 面板也主要是：
-
-- 文件列表
-- 文件详情
-- 文件下载/预览
-
-### 5.2 open-canvas 的关键能力
-
-open-canvas 的核心不是“生成文件”，而是“维护一个结构化的当前文档对象”：
-
-- 一个 conversation 对应一个主 artifact
-- artifact 具有类型、标题、内容、版本
-- 用户可以选中部分内容让 AI 改写
-- 每次改写都会生成新版本
-
-### 5.3 需要新增的核心能力
-
-为支持 Canvas 模式，需要在 DeerFlow 中新增一套结构化 artifact 状态：
-
-- 当前 artifact
-- 当前版本索引
-- 历史版本列表
-- 选区信息
-- 当前编辑模式
-- 快速动作状态
-- Web 搜索结果状态
-
----
-
-## 6. 分阶段实施方案
-
-以下为推荐的 8 个阶段，每个阶段都可单独开发、联调和验收。
-
----
-
-## 7. 阶段一：前端路由与目录骨架
-
-### 7.1 目标
-
-在不影响现有页面的前提下，建立 Canvas 模式的前端骨架。
-
-### 7.2 需求
-
-- 新增 `src/open-canvas/` 目录
-- 新增 Canvas 页面路由
-- 将路由接入 [PageRoutes.tsx](../src/pages/PageRoutes.tsx)
-- 提供 Canvas 首页和 Canvas Thread 页
-- 支持空状态展示
-
-### 7.3 建议目录
-
-```text
-src/open-canvas/
-  api/
-    threads.ts
-    runs.ts
-    models.ts
-  components/
-    layout/
-    chat/
-    canvas/
-    artifacts/
-    quick-actions/
-    selectors/
-  contexts/
-    CanvasThreadContext.tsx
-    CanvasGraphContext.tsx
-    CanvasUIContext.tsx
-  hooks/
-    useCanvasThread.ts
-    useCanvasStream.ts
-    useCanvasArtifact.ts
-  pages/
-    CanvasHomePage.tsx
-    CanvasThreadPage.tsx
-  routes/
-    OpenCanvasRoutes.tsx
-  types/
-    artifact.ts
-    thread.ts
-    model.ts
-  utils/
-    artifact.ts
-    selection.ts
-    stream.ts
-  constants/
-    index.ts
-```
-
-### 7.4 路由建议
-
-- 在 `PageRoutes.tsx` 中新增 `canvas/*`
-- 在 `src/open-canvas/routes/OpenCanvasRoutes.tsx` 中维护子路由
-
-建议形式：
-
-```text
-/canvas
-/canvas/:threadId
-```
-
-### 7.5 验收标准
-
-- 能访问 Canvas 首页
-- 能访问指定 thread 的 Canvas 页面
-- 不影响现有 `workspace/*` 与 `strategy/*`
-- 页面有独立布局骨架
-
----
-
-## 8. 阶段二：前端 Canvas 布局与交互容器
-
-### 8.1 目标
-
-先做出“左聊天、右画布”的基础容器，不接真实 AI 改写逻辑。
-
-### 8.2 需求
-
-- 左侧聊天区
-- 右侧画布区
-- 支持面板拖拽或折叠
-- 初始空状态
-- 支持“快速开始”：
-  - 新建空白文本 artifact
-  - 新建代码 artifact
-
-### 8.3 组件拆分建议
-
-- `CanvasShell`
-- `CanvasSidebar`
-- `CanvasChatPanel`
-- `CanvasArtifactPanel`
-- `CanvasEmptyState`
-- `QuickStartActions`
-
-### 8.4 快速开始能力
-
-用户进入空线程时可以选择：
-
-- 开始写文章
-- 开始写代码
-- 从模板开始
-
-首版模板可只做最小集：
-
-- 空白文档
-- HTML 模板
-- React 组件模板
-- Python 脚本模板
-
-### 8.5 验收标准
-
-- 页面可稳定展示双栏布局
-- 快速开始能创建前端本地 artifact 状态
-- 代码和文本可分别进入不同渲染器
-
----
-
-## 9. 阶段三：结构化 Artifact 数据模型
-
-### 9.1 目标
-
-定义 DeerFlow 的 Canvas Artifact 协议，作为前后端统一契约。
-
-### 9.2 核心要求
-
-需要支持以下能力：
-
-- 文本 artifact
-- 代码 artifact
-- 标题
-- 当前版本索引
-- 版本历史
-- 当前选中版本切换
-- 后续支持局部高亮编辑
-
-### 9.3 建议数据结构
-
-```ts
-type CanvasArtifact = {
-  currentIndex: number;
-  contents: Array<CanvasArtifactText | CanvasArtifactCode>;
-};
-
-type CanvasArtifactText = {
-  index: number;
-  type: "text";
-  title: string;
-  fullMarkdown: string;
-};
-
-type CanvasArtifactCode = {
-  index: number;
-  type: "code";
-  title: string;
-  language: string;
-  code: string;
-};
-```
-
-### 9.4 线程状态建议新增字段
-
-前端与后端需共同支持：
-
-- `artifact`
-- `highlighted_text`
-- `highlighted_code`
-- `canvas_mode`
-- `web_search_enabled`
-- `web_search_results`
-- `quick_action_id`
-
-### 9.5 与现有 `artifacts: string[]` 的关系
-
-建议保留现有 `artifacts: string[]` 不动。
-
-新增字段：
-
-- `artifact` 用于 Canvas 主文档
-- `artifacts` 继续用于文件产物
-
-这样可以兼容未来“Canvas 生成网页文件、导出文件、保存文件”的场景。
-
-### 9.6 验收标准
-
-- 前端类型定义完成
-- 后端状态字段设计完成
-- 确认与现有线程状态兼容
-
----
-
-## 10. 阶段四：后端线程状态与 API 扩展
-
-### 10.1 目标
-
-让后端线程状态可以安全存储和返回 Canvas Artifact。
-
-### 10.2 需求
-
-- 扩展 Python `ThreadState`
-- 扩展状态序列化逻辑
-- 确保 `/api/threads/*` 返回结构化 `artifact`
-- 确保 LangGraph 流中可带上 `artifact` 更新
-
-### 10.3 后端改造点
-
-建议关注以下模块：
-
-- `packages/harness/deerflow/agents/thread_state.py`
-- 线程 state serializer
-- `app/gateway/routers/threads.py`
-- 流事件适配层
-
-### 10.4 注意事项
-
-- 旧线程没有 `artifact` 字段时必须兼容
-- 状态更新不能破坏现有消息结构
-- 必须确保 JSON 可序列化
-
-### 10.5 验收标准
-
-- 新建线程可写入 `artifact`
-- 读取线程时可返回 `artifact`
-- 不影响现有线程读取
-- 前端能从线程 state 中恢复 Canvas 内容
-
----
-
-## 11. 阶段五：Canvas 专用 Agent 图
-
-### 11.1 目标
-
-实现与 open-canvas 类似的 AI 路由能力。
-
-### 11.2 推荐方案
-
-新增 `canvas_agent`，单独维护图逻辑。
-
-### 11.3 节点拆分建议
-
-首版建议至少拆成这些节点：
-
-- `route_user_intent`
-- `reply_general_input`
-- `generate_artifact`
-- `rewrite_artifact`
-- `update_highlighted_text`
-- `update_highlighted_code`
-- `generate_followup`
-
-二期可加：
-
-- `rewrite_artifact_theme`
-- `rewrite_code_theme`
-- `change_length`
-- `change_reading_level`
-- `translate_artifact`
-- `add_comments`
-- `add_logs`
-- `fix_bugs`
-- `port_language`
-- `web_search_enrich`
-
-### 11.4 路由逻辑要求
-
-系统需要能判断：
-
-- 用户是在闲聊
-- 用户要新生成 artifact
-- 用户要整体重写当前 artifact
-- 用户要局部修改当前 artifact
-- 用户要执行某个快捷动作
-
-### 11.5 状态输入要求
-
-节点需要读取：
-
-- 当前消息历史
-- 当前 artifact
-- 当前选区
-- 当前模型配置
-- Web 搜索开关
-
-### 11.6 输出要求
-
-节点输出必须能更新：
-
-- `messages`
-- `artifact`
-- `web_search_results`
-- `followup`
-
-### 11.7 验收标准
-
-- 能根据输入创建新 artifact
-- 能根据输入整体改写 artifact
-- 能保留版本历史
-- 能在改写后返回自然语言 followup
-
----
-
-## 12. 阶段六：前端流式同步与版本管理
-
-### 12.1 目标
-
-让前端能像 open-canvas 一样在流式过程中更新画布与聊天。
-
-### 12.2 需求
-
-- 复用现有 LangGraph stream client
-- 在 Canvas 模式中解析 `artifact` 更新
-- 支持流式文本更新
-- 支持版本切换
-- 支持断线后恢复线程状态
-
-### 12.3 前端状态层建议
-
-- `CanvasThreadContext`：线程基础信息
-- `CanvasGraphContext`：消息、artifact、streaming 状态
-- `CanvasUIContext`：面板、编辑态、选中态
-
-### 12.4 关键能力
-
-- 当前版本切换
-- 新版本创建后自动定位到最新版本
-- 手动编辑内容后保存
-- 流结束后线程状态持久化
-
-### 12.5 验收标准
-
-- 发送消息时聊天和画布可同步更新
-- 版本数会增加
-- 切换历史版本稳定
-- 刷新页面后线程状态能恢复
-
----
-
-## 13. 阶段七：局部选区改写
-
-### 13.1 目标
-
-实现 Canvas 模式最关键的差异化能力之一：选中局部内容进行 AI 改写。
-
-### 13.2 文本选区需求
-
-- 支持在 Markdown 文本中选择一段文本
-- 记录选区位置与原始文本
-- 用户发出修改请求后，仅重写该选区
-- 将选区结果合并为新版本 artifact
-
-### 13.3 代码选区需求
-
-- 支持在代码编辑器中选择一段代码
-- 记录 start/end index 或行列信息
-- AI 只返回替换片段
-- 前端或后端负责将新片段拼接回完整代码
-
-### 13.4 实现建议
-
-首版建议：
-
-- 文本：前端记录纯文本字符位置
-- 代码：使用 CodeMirror selection 信息
-
-不建议首版就做复杂块级富文本局部编辑。
-
-### 13.5 风险
-
-- Markdown 渲染态与源码态位置映射复杂
-- 富文本块级位置难维护
-- 流式更新中选区同步容易错位
-
-### 13.6 首版折中方案
-
-首版文本只基于 `fullMarkdown` 纯文本改写，不做 BlockNote 富文本块定位。
-
-### 13.7 验收标准
-
-- 文本局部改写成功
-- 代码局部改写成功
-- 原内容未改动部分保持不变
-- 新版本正确入历史
-
----
-
-## 14. 阶段八：快捷动作系统
-
-### 14.1 目标
-
-实现 open-canvas 风格的快捷动作体系。
-
-### 14.2 首批推荐动作
-
-文本类：
-
-- 扩写
-- 精简
-- 改正式语气
-- 改口语语气
-- 改阅读难度
-- 翻译
-
-代码类：
-
-- 加注释
-- 加日志
-- 修复 bug
-- 优化代码
-- 转换语言
-
-### 14.3 设计方式
-
-快捷动作不要直接写死在 UI，建议配置化：
-
-- `id`
-- `label`
-- `type`
-- `applicable_to`
-- `prompt_template`
-
-### 14.4 后端设计
-
-快捷动作可通过：
-
-- 前端传 `quick_action_id`
-- 后端路由节点根据动作 id 选择 prompt
-
-### 14.5 验收标准
-
-- 文本动作可执行
-- 代码动作可执行
-- 结果进入新版本
-- 不同动作提示词可扩展
-
----
-
-## 15. 阶段九：模型配置统一与本地模型支持
-
-### 15.1 目标
-
-让 Canvas 模式支持和主系统统一的模型选择，并且能自由配置本地大模型。
-
-### 15.2 原则
-
-- 后端 `config.yaml` 为真源
-- 前端只展示后端暴露的模型信息
-- 不维护一份脱离后端的前端常量模型表
-
-### 15.3 本地模型支持范围
-
-建议优先支持两类：
-
-- `Ollama`
-- OpenAI-compatible 本地服务
-  - LM Studio
-  - vLLM
-  - LocalAI
-  - one-api 风格代理
-
-### 15.4 后端配置建议
-
-后端模型配置应至少支持：
-
-- `name`
-- `display_name`
-- `use`
-- `model`
-- `api_key`
-- `base_url`
-- `supports_vision`
-- `supports_thinking`
-- `supports_tool_calling`
-- `is_local`
-- `canvas_capabilities`
-
-### 15.5 Canvas 模式额外要求
-
-由于不是所有模型都适合 Canvas 改写任务，建议增加能力标识：
-
-- `supports_canvas_generation`
-- `supports_canvas_rewrite`
-- `supports_canvas_code_edit`
-- `supports_streaming_text`
-- `supports_streaming_tool_calls`
-
-### 15.6 与 open-canvas 的关系
-
-可以借鉴其命名习惯和能力分层，但不建议直接依赖其 `packages/shared/src/models.ts` 作为配置源。
-
-### 15.7 验收标准
-
-- 前端模型选择器可显示后端返回模型
-- 可切换本地模型
-- Canvas 模式能用本地模型生成和改写
-
----
-
-## 16. 阶段十：Web 搜索增强
-
-### 16.1 目标
-
-实现类似 open-canvas 的可选 Web 搜索增强。
-
-### 16.2 需求
-
-- UI 提供 Web 搜索开关
-- 后端在需要时走搜索节点
-- 搜索结果写入线程状态
-- 结果可在画布旁侧栏展示
-
-### 16.3 首版建议
-
-只做：
-
-- 开关
-- 搜索结果列表
-- 搜索结果用于生成 artifact
-
-暂不做复杂网页抓取编辑链路。
-
-### 16.4 验收标准
-
-- 打开搜索后可返回搜索结果
-- 搜索结果可参与 artifact 生成
-- 结果展示不阻塞主画布
-
----
-
-## 17. 阶段十一：持久化、导出与文件产物联动
-
-### 17.1 目标
-
-让 Canvas 文档与 DeerFlow 原有文件能力协同。
-
-### 17.2 需求
-
-- artifact 持久化在线程 state 中
-- 可手动导出为文件
-- 可生成真实 HTML/Markdown/代码文件到现有 outputs
-- Canvas artifact 与 `artifacts: string[]` 可双向关联
-
-### 17.3 推荐能力
-
-- 导出 Markdown
-- 导出代码文件
-- 另存为 artifact file
-- 从 artifact file 回填到 Canvas
-
-### 17.4 验收标准
-
-- 当前版本可导出
-- 导出文件可在现有文件面板查看
-- 文件型 artifact 和 Canvas artifact 能共存
-
----
-
-## 18. 推荐开发顺序
-
-建议严格按以下顺序推进：
-
-1. 路由和目录骨架
-2. Canvas 页面布局
-3. 前端 artifact 数据模型
-4. 后端线程状态扩展
-5. 新建 Canvas Agent 图
-6. 前后端流式同步
-7. 整体生成与整体改写
-8. 局部选区改写
-9. 快捷动作
-10. 本地模型支持完善
-11. Web 搜索增强
-12. 导出与文件联动
-
-不要先做局部改写和快捷动作，否则前面的状态与路由契约不稳定，返工会很多。
-
----
-
-## 19. 里程碑定义
-
-### M1：页面可进入
-
-- 路由接通
-- 双栏布局完成
-- 本地 mock artifact 可渲染
-
-### M2：后端状态打通
-
-- 线程可保存结构化 artifact
-- 页面刷新后能恢复
-
-### M3：AI 生成可用
-
-- 可新建文本/代码 artifact
-- 可整体改写
-- 可产生版本历史
-
-### M4：核心体验可用
-
-- 选区改写可用
-- 快捷动作可用
-- 模型切换可用
-
-### M5：增强能力完整
-
-- 本地模型支持完善
-- Web 搜索增强
-- 导出和文件联动
-
----
-
-## 20. 风险与难点
-
-### 20.1 最大难点
-
-- 结构化 artifact 状态从无到有
-- 局部选区改写的精确性
-- 流式状态与版本管理的一致性
-- 不破坏现有 DeerFlow 文件型 artifact 体系
-
-### 20.2 技术风险
-
-- 线程 state JSON 结构过大
-- 大模型对局部改写指令遵循不稳定
-- 本地模型 tool calling 与流式能力差异大
-- 文本渲染态与源码态位置映射复杂
-
-### 20.3 规避建议
-
-- 首版只支持 Markdown 源码态编辑，不做复杂富文本编辑
-- 首版只支持文本和代码两种 artifact 类型
-- 首版先做整体生成和整体改写，再做局部改写
-- 本地模型先支持“能生成、能重写”的最小能力，不强求与顶级闭源模型完全同效
-
----
-
-## 21. 验收总清单
-
-### 21.1 前端
-
-- 有独立 Canvas 路由
-- 有专用目录和模块边界
-- 双栏布局可用
-- 文本和代码两类 artifact 可渲染
-- 历史版本可切换
-- 选区改写可交互
-- 快捷动作可触发
-- 模型可切换
-
-### 21.2 后端
-
-- 线程状态支持 `artifact`
-- 新增 `canvas_agent` 或等价模式
-- 生成、重写、局部改写可用
-- 流式返回稳定
-- 模型列表接口支持 Canvas 能力元数据
-
-### 21.3 本地模型
-
-- 可配置 Ollama
-- 可配置 OpenAI-compatible 本地服务
-- 前端可见并可切换
-- 至少能完成文本生成和整体改写
-
----
-
-## 22. 推荐首版最小可交付范围
-
-如果要控制风险，建议首版只交付以下内容：
-
-- 新增 `canvas/*` 路由
-- 双栏布局
-- 结构化 `artifact`
-- `canvas_agent`
-- 文本/代码 artifact 新建
-- 整体生成
-- 整体改写
-- 历史版本切换
-- 后端模型动态加载
-- Ollama 或本地 OpenAI-compatible 至少一种可用
-
-先不要把以下内容放进首版强制目标：
-
-- 富文本块级精确编辑
-- 全量快捷动作
-- 复杂 Web 搜索增强
-- 多 artifact 并行管理
-
----
-
-## 23. 后续实施建议
-
-建议下一步基于本文档继续输出两份落地文档：
-
-### 23.1 前端实施清单
-
-逐文件列出：
-
-- 要新建哪些文件
-- 哪些组件可复用
-- 哪些页面要接入路由
-- 哪些状态要从现有 hooks 抽离
-
-### 23.2 后端实施清单
-
-逐模块列出：
-
-- 要改哪些 Python 文件
-- 新增哪些状态字段
-- 新增哪些 Agent 节点
-- 哪些 API 需要扩展
-
----
-
-## 24. 结论
-
-这个需求很大，但完全可拆。
-
-正确做法不是“先抄 UI”，而是按下面的主线推进：
-
-- 先建前端 Canvas 子系统
-- 再建结构化 artifact 状态
-- 再建 Canvas Agent 图
-- 再补局部改写和快捷动作
-- 最后统一本地模型能力
-
-只要按本文档阶段推进，这个需求是可以落地的，而且能和你现在的 DeerFlow 架构保持长期兼容。

frontend-web/docs/position-roundtable-delivery-workflow-plan.md

@@ -0,0 +1,362 @@
+# 岗位会商交付闭环与内置智能体实现计划
+
+> 页面：`/page/strategy/qa/position-roundtable`
+>
+> 目标：在现有岗位会商基础上补齐“产物交付、查看、驳回、方案总结、行动规划”的完整闭环，同时继续保持原多智能体会商页面不受影响。
+
+## 实施核对（2026-07-21）
+
+本计划已按“岗位会商独立路由、无总控、各席位直接问答”的边界完成第一轮闭环。实际流程调整为：
+
+```text
+任务信息 → 情报分析岗识别并确认意图 → 启动校验并冻结业务链
+→ 分阶段席位直接问答/交付 Markdown → 全部有效交付
+→ 方案总结智能体（roundtable-summary）→ 行动规划智能体（position-action-planner）
+→ 可随时返回交付产物驳回 → 后续阶段及内置产物级联失效 → 重做后重新收口
+```
+
+- [x] 情报意图、业务链选择、席位岗位归属和席位智能体配置均在启动前校验；启动后保存业务链快照。
+- [x] 普通席位直接调用各自分配的智能体，并注入任务、意图及已完成上游席位的问答/产物；不经过总控智能体。
+- [x] 普通席位必须在 `outputs` 中交付 Markdown 才会完成；情报分析岗以确认的结构化意图完成为准。
+- [x] 节点、交付卡片、流程图和大图弹窗均展示 `locked / ready / running / done / rejected / stale / error` 状态，并可回看节点会话和产物。
+- [x] 驳回要求标题和理由；当前节点转为 `rejected`，后续阶段按依赖转为 `stale/locked`，总结和行动规划同时失效，历史内容保留可查看。
+- [x] 被驳回或失效的普通席位必须写入一份**新的或已改写** Markdown 才能再次完成；单纯继续问答且没有新交付不会误使下游产物失效。
+- [x] 方案总结复用 `roundtable-summary` 的真实流式线程；行动规划新增 `position-action-planner`，强制输出 Markdown 报告和 `action-plan-subtasks.json`。
+- [x] 两个内置智能体的线程、产物快照和来源节点版本栅栏均持久化；流式期间若上游版本变化，旧运行不能覆盖最新状态。
+- [x] 右侧“交付产物”可查看内置节点结果、继续同一线程问答/修改交付，并在打开 Markdown 沙箱时自动收起右栏。
+
+设计收敛：当前版本以节点的 `artifact_manifest`、`latest_answer`、版本、驳回记录及 Session 内置快照作为唯一事实来源，已能覆盖统一产物卡片和级联逻辑，因此不新增重复的 `position_roundtable_deliverables` 表。若后续需要“单个文件独立驳回、跨会话检索或完整版本对比”，再将清单归一化为独立产物表，避免现在的双写一致性风险。
+
+## 数据持久化与灾难恢复（2026-07-23）
+
+岗位会商现在使用“两层持久化”，两层职责不同：
+
+1. LangGraph checkpoint/thread 是智能体继续推理与流式问答的执行源。
+2. `position_roundtable_sessions` / `position_roundtable_nodes` 是页面历史的数据库恢复源。
+
+数据库恢复源会保存：
+
+- 情报分析岗完整消息、步骤时间线和未发送输入草稿；
+- 每个业务链岗位的完整消息和未发送输入草稿；
+- 方案总结、行动规划两个收口智能体的完整消息和未发送输入草稿；
+- 已确认意图、冻结任务与业务链快照、节点状态、版本、驳回记录；
+- Markdown / JSON 等文本产物正文（单文件最多 400 万字符）和文件元数据。
+
+因此即使线上重启后 checkpoint 或沙箱 outputs 卷丢失，历史页仍能从数据库展示对话与产物正文，后续收口智能体也能继续读取数据库中的有效上游交付。新任务在意图识别开始前就会创建 Session，用户不必等到“启动业务链”才获得持久化保护。历史下拉支持删除，删除会显式清理 Session 与全部节点恢复快照，不依赖 SQLite 外键开关。
+
+对应迁移：`20260723_05_position_roundtable_conversations.py`。部署时必须执行到 Alembic head。
+
+## 0. 核心结论
+
+- 方案总结智能体建议复用现有会商里的 `roundtable-summary` 能力，但不要直接搬整套 Step 3 页面流程。
+  - 可复用：内置智能体 ID、总结报告 prompt 组织方式、Markdown 报告产物、流式对话、报告续问与文件预览能力。
+  - 需要改造：输入材料从“总控共识 + 各席位交付”改成“任务信息 + 意图结果 + 已通过的岗位产物 + 业务链快照”，并把结果存到岗位会商 Session 下。
+- 行动规划智能体建议作为新的内置智能体新增。
+  - 输入：方案总结报告、各岗位最终有效产物、业务链阶段信息、任务意图。
+  - 输出：行动规划报告、结构化子任务清单。
+- 这个模式仍然不需要总控智能体。情报分析岗负责意图识别，业务链节点直接调用各自配置的智能体，最终再由内置总结/规划智能体收口。
+- 驳回不删除历史内容，只改变“当前有效版本”的状态；被驳回节点和后续节点需要重新交付，既保留可追溯性，也方便后续返回查看。
+
+## 1. 目标业务流程
+
+1. 情报分析岗进入页面，查看任务信息并完成意图识别。
+2. 用户点击“确认意图并启动业务链”。
+3. 启动前做校验：
+   - 未选择业务链：提示“请先选择业务链”。
+   - 业务链存在未配置岗位的席位：提示并引导去业务链配置页。
+   - 业务链席位缺少智能体：提示具体席位名称。
+   - 意图尚未完成：提示先完成任务意图识别。
+4. 校验通过后冻结业务链快照，初始化岗位会商节点。
+5. 各岗位只对分配给本岗位的智能体进行问答。
+6. 节点问答完成后形成交付产物，右侧产物卡片显示“已完成 / 未完成 / 进行中 / 已驳回 / 已失效”。
+7. 左侧流程图显示各节点状态，节点可点击查看该节点对话与产物。
+8. 流程图右上角提供“查看”按钮，打开弹窗展示更完整的业务链流程图。
+9. 当业务链中所有岗位产物都处于有效已交付状态后，开放“方案总结”。
+10. 方案总结完成后开放“行动规划”。
+11. 即使进入方案总结或行动规划，用户仍可返回产物列表执行驳回。
+12. 若驳回早期阶段产物，后续阶段产物、方案总结、行动规划都一起失效并回到待重新完成状态。
+
+## 2. 状态设计
+
+### 2.1 节点状态
+
+现有节点状态需要扩展或映射为更贴近页面的展示状态：
+
+| 展示状态 | 建议内部状态 | 含义 |
+| --- | --- | --- |
+| 未完成 | `ready` / `locked` / `rejected` | 尚未有效交付，或被驳回后等待重做 |
+| 进行中 | `running` | 当前智能体正在回答或产物正在生成 |
+| 已完成 | `done` | 当前节点已有有效交付 |
+| 已失效 | `stale` | 上游被更新或驳回，当前结果不可作为最终材料 |
+| 异常 | `error` | 生成或保存失败 |
+
+建议新增 `rejected` 状态，便于区分“从未完成”和“被驳回后待重做”。如果第一轮想少改后端，也可以先用 `ready + rejection_record` 表示被驳回。
+
+### 2.2 产物状态
+
+产物状态建议独立于节点状态保存，因为一个节点可能同时有回答文本和多个文件产物。
+
+| 状态 | 含义 |
+| --- | --- |
+| `pending` | 还没有交付 |
+| `running` | 正在生成 |
+| `delivered` | 已交付且当前有效 |
+| `rejected` | 被用户驳回 |
+| `stale` | 受上游驳回或重做影响，已经失效 |
+
+### 2.3 内置收口节点
+
+在流程图中把两个内置节点追加到业务链末尾：
+
+1. `builtin:summary`：方案总结智能体。
+2. `builtin:action-plan`：行动规划智能体。
+
+这两个节点不属于普通业务链席位，但要和普通节点一样显示状态、支持点击查看结果。
+
+## 3. 数据模型调整
+
+### 3.1 Session 扩展
+
+`position_roundtable_sessions` 已使用下列持久化字段：
+
+| 字段 | 含义 |
+| --- | --- |
+| `status` | `intent_pending / active / completed / archived`；总结/规划运行态由前端瞬时状态与对应快照的 `status` 表示，避免一次运行中断后留下伪运行态 |
+| `summary_thread_id` | 方案总结智能体线程 |
+| `summary_snapshot` | 最新有效总结报告快照 |
+| `action_plan_thread_id` | 行动规划智能体线程 |
+| `action_plan_snapshot` | 最新有效行动规划快照 |
+| `invalidated_at` | 记录在 `summary_snapshot` / `action_plan_snapshot` 内，包含 `invalidated_by`，无需重复写 Session 字段 |
+
+### 3.2 Node 扩展
+
+`position_roundtable_nodes` 已使用下列字段（展示状态由前端按状态映射）：
+
+| 字段 | 含义 |
+| --- | --- |
+| `status` | `locked / ready / running / done / stale / rejected / error`，前端直接映射为展示状态 |
+| `rejection_count` | 当前节点累计驳回次数 |
+| `last_rejection` | 最新驳回标题、理由、操作者、时间 |
+| `revision` | 当前有效交付版本 |
+| `invalidated_by` | 导致当前节点失效的上游节点 key |
+
+### 3.3 Deliverable 新表（后续可选）
+
+当需要“单个文件独立驳回、跨会话检索或完整版本对比”时，再新增 `position_roundtable_deliverables`，不要只依赖 `artifact_manifest`。
+
+| 字段 | 含义 |
+| --- | --- |
+| `id` | 产物 ID |
+| `session_id` | 会话 ID |
+| `node_key` | 来源节点 |
+| `agent_id` | 来源智能体 |
+| `position_id` | 来源岗位 |
+| `title` | 产物名称 |
+| `kind` | `answer / file / summary / action_plan` |
+| `content` | 文本产物内容摘要或正文 |
+| `artifact_path` | 文件产物虚拟路径 |
+| `thread_id` | 所属线程 |
+| `status` | `pending / running / delivered / rejected / stale` |
+| `revision` | 来源节点版本 |
+| `rejection_title` | 驳回标题 |
+| `rejection_reason` | 驳回理由 |
+| `created_at` | 创建时间 |
+| `updated_at` | 更新时间 |
+
+当前第一轮不新增这张表：右侧产物卡片、驳回记录、总结输入材料从节点 `artifact_manifest`、节点版本/驳回记录和 Session 快照聚合，避免节点表与产物表双写。后续引入该表时，应把它提升为唯一事实来源，而不是并行维护两套状态。
+
+## 4. 驳回与级联失效规则
+
+### 4.1 基本驳回
+
+用户点击产物卡片的“驳回”后弹窗填写：
+
+- 驳回标题。
+- 驳回理由。
+
+提交后：
+
+- 当前产物状态改为 `rejected`。
+- 当前节点状态改为 `rejected` 或 `ready`。
+- 当前节点的 `latest_answer` 和历史文件不删除，但不再作为有效交付输入。
+- 记录 `last_rejection`，用于页面展示和后续追踪。
+
+### 4.2 级联失效
+
+如果驳回的节点位于第 N 阶段：
+
+- 同阶段其他节点不自动驳回，除非业务链未来明确配置了依赖关系。
+- 第 N+1 阶段及之后所有节点的有效产物全部标记为 `stale`。
+- 后续节点状态回到未完成展示态。
+- `builtin:summary` 和 `builtin:action-plan` 如果已经生成，也标记为 `stale`。
+- 页面允许用户继续查看旧报告和旧行动规划，但必须提示“上游产物已变更，需要重新生成”。
+
+### 4.3 重新交付
+
+被驳回节点重新问答并完成后：
+
+- 当前节点产生新的 `revision`。
+- 当前节点产物状态变为 `delivered`。
+- 只有当该阶段所有必要节点都重新有效交付后，下一阶段才重新解锁。
+- 方案总结和行动规划必须基于最新有效产物重新生成。
+
+## 5. 接口规划
+
+### 5.1 启动与校验
+
+| 方法 | 路径 | 用途 |
+| --- | --- | --- |
+| `POST` | `/api/position-roundtable/sessions/{id}/validate-activation` | 校验业务链、岗位、智能体、意图状态 |
+| `POST` | `/api/position-roundtable/sessions/{id}/activate` | 校验通过后冻结链条并初始化节点 |
+
+第一轮也可以先把校验合并在 `activate` 内，前端根据后端返回的错误码提示。
+
+### 5.2 产物
+
+| 方法 | 路径 | 用途 |
+| --- | --- | --- |
+| `GET` | `/api/position-roundtable/sessions/{id}/results` | 获取右侧统一产物来源节点（前端聚合文件与内置快照） |
+| `GET` | `/api/position-roundtable/sessions/{id}/nodes/{node_key}` | 获取节点详情；文件正文由既有线程产物预览接口读取 |
+| `POST` | `/api/position-roundtable/sessions/{id}/nodes/{node_key}/reject` | 驳回当前节点交付并触发级联失效 |
+| `POST` | `/api/position-roundtable/sessions/{id}/nodes/{node_key}/complete-turn` | 节点回答结束后同步回答与产物 |
+
+### 5.3 方案总结与行动规划
+
+| 方法 | 路径 | 用途 |
+| --- | --- | --- |
+| `POST` | `/api/position-roundtable/sessions/{id}/summary/prepare` | 服务端准备版本锁定的总结材料和线程信息 |
+| `POST` | `/api/position-roundtable/sessions/{id}/summary/ask` | 服务端准备总结的同线程续问材料 |
+| `POST` | `/api/position-roundtable/sessions/{id}/summary/complete` | 校验 Markdown 交付与来源版本后持久化总结快照 |
+| `POST` | `/api/position-roundtable/sessions/{id}/action-plan/prepare` | 服务端准备行动规划材料和线程信息 |
+| `POST` | `/api/position-roundtable/sessions/{id}/action-plan/ask` | 服务端准备行动规划同线程续问材料 |
+| `POST` | `/api/position-roundtable/sessions/{id}/action-plan/complete` | 校验 Markdown + JSON 交付与来源版本后持久化行动规划快照 |
+
+可以复用现有 `streamMultiAgent` 流式协议，但建议在岗位会商下包一层 API，由后端负责拼装岗位会商材料，前端不直接拼长 prompt。
+
+## 6. 前端实施步骤
+
+### 阶段 1：状态与启动校验（已完成）
+
+- 扩展 `PositionNodeStatus` 和状态显示映射。
+- “确认意图并启动业务链”前补齐校验提示。
+- 后端 `activate` 返回未配置岗位、缺智能体、未选择链条等具体错误。
+- 左侧流程图节点右上角添加状态小图标。
+- 节点样式调整为上方智能体名称、下方岗位名称，移除左侧 logo。
+
+验收标准：未选择业务链、岗位未配齐、意图未完成时都能准确阻止启动；启动后流程图能显示各节点状态。
+
+### 阶段 2：流程图弹窗（已完成）
+
+- 左侧保留小型从上到下流程图。
+- 流程图右上角增加“查看”按钮。
+- 点击后打开弹窗，展示更大的流程图。
+- 弹窗内支持点击节点查看对话与产物，保持和主页面选中节点同步。
+
+验收标准：小图不挤占左侧空间，大图能完整展示业务链和两个内置收口节点。
+
+### 阶段 3：产物卡片与预览（已完成）
+
+- 右侧新增或改造“分析结果”Tab 为“交付产物”列表。
+- 卡片展示智能体名称、产物名称、岗位名称、时间、状态。
+- 点击卡片打开详情弹窗。
+- 文本产物直接展示正文，文件产物复用现有 `ArtifactPreviewModal`。
+- 每个有效产物提供“驳回”入口。
+
+验收标准：节点回答和文件产物能进入统一产物列表；点击可查看详情。
+
+### 阶段 4：驳回弹窗与级联失效（已完成）
+
+- 新增 `RejectDeliverableDialog`。
+- 驳回表单包含标题和理由，均必填。
+- 后端事务内完成当前产物驳回、当前节点状态更新、后续阶段级联失效、总结和行动规划失效。
+- 前端刷新 Session、Node、Deliverable 和流程图状态。
+- 被驳回节点在对话区显示驳回信息，提示用户重新交付。
+
+验收标准：驳回第一阶段任意节点后，第二阶段及之后产物都显示未完成或已失效；旧内容可查看但不能作为总结输入。
+
+### 阶段 5：方案总结智能体（已完成）
+
+- 封装 `usePositionSummary`，内部复用 `roundtable-summary` 的线程初始化、流式输出和 Markdown 产物预览能力。
+- 输入材料改为岗位会商材料：
+  - 任务信息。
+  - 情报分析岗意图结果。
+  - 业务链快照。
+  - 所有状态为 `delivered` 的岗位产物。
+  - 已驳回或失效产物只作为历史参考，不进入默认总结材料。
+- 方案总结节点追加到流程图末尾。
+- 所有产物有效交付后才允许点击“生成方案总结”。
+- 总结结果写入 `summary_snapshot`，同时进入产物列表。
+
+验收标准：总结报告使用现有方案总结能力生成 Markdown；刷新页面后可恢复；上游驳回后总结标记失效。
+
+### 阶段 6：行动规划智能体（已完成）
+
+- 新增内置智能体 ID，建议先命名为 `position-action-planner`。
+- 新增行动规划 prompt：
+  - 读取方案总结报告。
+  - 读取各岗位最终有效产物。
+  - 拆解为若干子任务。
+  - 每个子任务包含名称、目标、输入依据、责任岗位建议、前置依赖、交付物、验收标准。
+- 输出两类产物：
+  - `行动规划报告.md`。
+  - `action-plan-subtasks.json`。
+- 行动规划节点追加到方案总结之后。
+- 方案总结有效完成后才允许启动行动规划。
+
+验收标准：行动规划能生成可读报告和结构化子任务；刷新可恢复；上游驳回后自动失效。
+
+### 阶段 7：返回修改与重新生成（已完成）
+
+- 用户在方案总结或行动规划视图中仍可切回“交付产物”。
+- 驳回后自动显示需要重做的节点。
+- 重做节点完成后，允许重新生成方案总结和行动规划。
+- 旧总结、旧行动规划保留历史查看，但状态显示“已失效”。
+
+验收标准：不会因为进入总结/规划阶段而锁死前序产物；前序重做后能形成新版本闭环。
+
+### 阶段 8：测试与回归（已完成）
+
+- 后端测试：
+  - activate 校验。
+  - 节点完成后产物入库。
+  - 驳回当前节点。
+  - 驳回第一阶段时后续阶段级联失效。
+  - 总结和行动规划失效。
+- 前端测试：
+  - 启动校验提示。
+  - 状态图标显示。
+  - 产物卡片筛选和预览。
+  - 驳回弹窗必填校验。
+- 回归验证：
+  - 原多智能体会商页面不受影响。
+  - 业务链普通配置入口不显示岗位配置。
+  - 岗位会商页面刷新恢复正常。
+  - 深色模式和嵌入模式布局不溢出。
+
+## 7. 推荐提交拆分
+
+1. `feat(position-roundtable): add delivery status model`
+2. `feat(position-roundtable): validate chain activation`
+3. `feat(position-roundtable): add workflow status graph`
+4. `feat(position-roundtable): add deliverable cards and preview`
+5. `feat(position-roundtable): support rejection cascade`
+6. `feat(position-roundtable): add summary builtin node`
+7. `feat(position-roundtable): add action planning builtin node`
+8. `test(position-roundtable): cover delivery workflow`
+
+## 8. 第一轮建议范围
+
+第一轮优先做最小可闭环：
+
+```text
+意图识别
+→ 启动校验
+→ 业务链节点状态
+→ 节点产物列表
+→ 产物详情查看
+→ 驳回与级联失效
+→ 全部交付后生成方案总结
+→ 基于总结生成行动规划
+```
+
+如果时间紧，行动规划可以先生成 Markdown 报告，结构化 `subtasks.json` 放到第二轮；但数据模型和 UI 入口第一轮就要预留，否则后面会返工。

frontend-web/docs/position-roundtable-sandbox/README.md

@@ -0,0 +1,15 @@
+# 岗位会商沙箱文档
+
+本目录存放**岗位会商文件预览沙箱**的对接与排障说明，独立于 `src/position-roundtable/docs/`，避免与模块内其它文档互相覆盖。
+
+| 文档 | 说明 |
+| --- | --- |
+| [沙箱打开关闭与步骤条.md](./沙箱打开关闭与步骤条.md) | **详细版**：打开/关闭完整时序、步骤条关系、对接接口字段说明、必守规则、历史 bug 根因、排障手册、自测清单、接线示例与代码索引 |
+
+模块总览仍见：`frontend-web/src/position-roundtable/README.md`。
+
+建议读法：
+
+- **从零对接新页面**：正文第 3、5、6、7、8、12、15、16 节  
+- **线上排障**：第 13、14 节  
+- **只要一页纸**：文末「附录 A」

frontend-web/docs/position-roundtable-sandbox/沙箱打开关闭与步骤条.md

@@ -0,0 +1,988 @@
+# 岗位会商 · 沙箱打开 / 关闭与步骤条（详细对接与排障指南）
+
+> **文档位置**：`frontend-web/docs/position-roundtable-sandbox/`  
+> **读者**：下次重做或对接岗位会商页面的同事；线上「沙箱不实时 / 卡死 / 第二次不刷新」时的排障同学。  
+> **最后依据**：当前仓库 `PositionRoundtablePage` + `PositionNodeChat` 实现（含临时名打开、外部 store、前沿节流、按 tool-call 重挂）。
+
+---
+
+## 目录
+
+1. [文档用途与读法](#1-文档用途与读法)
+2. [背景：为什么岗位会商要单独做沙箱](#2-背景为什么岗位会商要单独做沙箱)
+3. [用户可见的正确行为（验收标准）](#3-用户可见的正确行为验收标准)
+4. [整体架构与数据流](#4-整体架构与数据流)
+5. [职责划分：谁拥有什么状态](#5-职责划分谁拥有什么状态)
+6. [对接接口详解](#6-对接接口详解)
+7. [打开沙箱的完整步骤](#7-打开沙箱的完整步骤)
+8. [关闭沙箱的完整步骤](#8-关闭沙箱的完整步骤)
+9. [步骤条与沙箱的关系](#9-步骤条与沙箱的关系)
+10. [流式内容如何进入沙箱（性能关键）](#10-流式内容如何进入沙箱性能关键)
+11. [与普通对话页的对照](#11-与普通对话页的对照)
+12. [重做页面时的必守规则](#12-重做页面时的必守规则)
+13. [历史问题与根因（务必读）](#13-历史问题与根因务必读)
+14. [排障手册（按症状）](#14-排障手册按症状)
+15. [对接自测清单](#15-对接自测清单)
+16. [最小接线示例](#16-最小接线示例)
+17. [关键代码索引](#17-关键代码索引)
+18. [术语表](#18-术语表)
+
+---
+
+## 1. 文档用途与读法
+
+### 1.1 这份文档解决什么问题
+
+岗位会商右侧「文件预览沙箱」看起来像普通对话页的产物预览，但实现路径完全不同。历史上这块反复出过：
+
+- 沙箱不实时打开，要等全文写完才弹；
+- 打开了但内容冻住，生成完才一口气灌进去；
+- 整页卡顿，连消息列表文字都不实时；
+- 同轮「重新生成」第二次写入时，步骤条变了，沙箱却不动；
+- 第一次正常，关掉后再问就不实时。
+
+这些 bug **特别容易在「重做页面 / 换布局 / 自己重写开沙箱逻辑」时复现**。本文把正确对接方式、时序、接口、禁区和排障步骤写全，方便下一位同事直接按文档接线，而不是再靠猜。
+
+### 1.2 建议读法
+
+| 你的目标 | 先读哪些章节 |
+| --- | --- |
+| 从零接一个新页面壳 | 第 3、5、6、7、8、12、15、16 节 |
+| 只改对话子组件探测逻辑 | 第 7、9、12、13 节 |
+| 线上排障 | 第 13、14 节，必要时回看第 10 节 |
+| 理解为什么不能用页面 state | 第 2、10、13 节 |
+
+### 1.3 对照代码（以仓库为准）
+
+| 角色 | 路径 |
+| --- | --- |
+| 页面壳（唯一沙箱宿主） | `frontend-web/src/position-roundtable/pages/PositionRoundtablePage.tsx` |
+| 节点对话（探测 write_file、上报预览） | `frontend-web/src/position-roundtable/components/PositionNodeChat.tsx` |
+| 收口对话 | `frontend-web/src/position-roundtable/components/PositionBuiltinAgentChat.tsx` |
+| 预览 UI（共享组件，勿分叉逻辑） | `frontend-web/src/components/workspace/artifacts/artifact-file-detail.tsx` |
+| 流式正文读取 | `frontend-web/src/core/artifacts/loader.ts` → `loadArtifactContentFromToolCall` |
+| 普通对话页对照（步骤条自动开） | `frontend-web/src/components/workspace/messages/message-group.tsx` |
+| 模块总览 | `frontend-web/src/position-roundtable/README.md` |
+
+---
+
+## 2. 背景：为什么岗位会商要单独做沙箱
+
+### 2.1 普通对话页怎么开沙箱
+
+普通对话页（`ChatPage`）大致是：
+
+```text
+ArtifactsProvider（页面级）
+  └─ ChatBox / MessageList
+       └─ message-group 渲染 write_file 步骤
+            └─ 发现 path 且 autoOpen → artifacts.select + setOpen(true)
+  └─ 右侧 ArtifactFileDetail 读同一套 ThreadContext
+```
+
+要点：
+
+- 对话和预览共享同一套 `ThreadContext`（同一个 `useThreadStream`）。
+- 步骤条组件自己就能触发打开。
+- 流式 `content` 本来就在当前 React 树的 thread 里，不需要「把 thread 镜像到别的地方」。
+
+### 2.2 岗位会商为什么不能照搬
+
+岗位会商页面同时有：
+
+- 左侧任务 / 意图 / 流程图；
+- 中间某个节点的对话（`PositionNodeChat`）；
+- 右侧配置抽屉；
+- **以及一个页面级单例沙箱**，它是对话区的**兄弟节点**，不在 `PositionNodeChat` 的 ThreadContext 里面。
+
+因此：
+
+1. 沙箱拿不到节点对话内部的 `thread`，除非节点主动上报；
+2. 若把每次流式 thread 写进**页面级 `useState`**，整页（任务卡、意图、流程图、对话）都会按流式频率重渲染，主线程会被打爆；
+3. 页面必须自己决定「开 / 关 / 抑制自动再开 / 切节点时清理」，不能让多个子组件各自 `setOpen`。
+
+所以岗位会商采用：
+
+```text
+对话子组件探测 + 上报
+  → 页面壳统一打开唯一 ArtifactFileDetail
+  → 流式 thread 走外部 store，只让沙箱子树订阅
+```
+
+### 2.3 和「多智能体会商 Step2 沙箱」的区别
+
+仓库里还有 `frontend-web/docs/roundtable-step2-sandbox-progress.md`，那是另一套圆桌 Step2 沙箱进度文档，**不是**岗位会商这条链路。对接岗位会商时以本文为准。
+
+---
+
+## 3. 用户可见的正确行为（验收标准）
+
+重做或对接完成后，下列行为必须全部成立（用户感知对齐普通对话页）：
+
+| # | 行为 | 说明 |
+| --- | --- | --- |
+| A | 步骤条刚出现「写入文件」时，沙箱应已打开 | **不必等**步骤条上出现文件名 |
+| B | 沙箱源码边写边滚；消息列表也实时出字 | 不能整页卡死、不能「生成完一口气刷」 |
+| C | content 先于 path 时：先临时名打开，path 到了再改名 | 不闪屏、不重挂 |
+| D | 同轮第二次同路径 `write_file`（重新生成） | 沙箱清空并重新流式 |
+| E | 整轮结束后自动切 Markdown 预览 | 「正在生成，完成后自动预览」消失 |
+| F | 用户手动关闭后，同一次写入不再自动弹 | 下一轮新写入仍可自动开 |
+| G | 切岗位 / 切节点 / 新会话 / 切历史 | 沙箱关掉且不串内容 |
+
+**不要误判的正常现象：**
+
+- 流式期间沙箱停在「源码 / 编辑」视图，结束后才切「预览」——这是 `ArtifactFileDetail` 对 markdown/html 的既定行为，与普通对话页相同，**不是**打开时机 bug。
+- 步骤条长时间显示「写入文件」、没有路径，但沙箱已经打开并在滚动——content-first 模型下这是**预期**。
+
+---
+
+## 4. 整体架构与数据流
+
+```text
+┌──────────────────────────────────────────────────────────────────────────┐
+│ PositionRoundtablePage（页面壳）                                           │
+│                                                                          │
+│  state: sandboxArtifact | null                                           │
+│  ref:   sandboxArtifactRef / closedSandboxKeyRef / latestSnapshotRef     │
+│  store: createSandboxThreadStore()   ←── 禁止改成 useState               │
+│                                                                          │
+│  handlePreviewArtifact(artifact)  ←──────────────────────────────────┐   │
+│  handleNodeThreadSnapshot(...)    ←───────────────────────────────┐  │   │
+│  closeSandbox()                                                   │  │   │
+│                                                                   │  │   │
+│  {sandboxOpen && (                                                │  │   │
+│     SandboxThreadProvider(store)                                  │  │   │
+│       └─ ArtifactFileDetail key=sandboxCloseKey(...)              │  │   │
+│  )}                                                               │  │   │
+└───────────────────────────────────────────────────────────────────│──│───┘
+                                                                    │  │
+┌───────────────────────────────────────────────────────────────────│──│───┐
+│ PositionNodeChat / PositionBuiltinAgentChat                         │  │   │
+│                                                                   │  │   │
+│  useThreadStream → thread.messages / thread.isLoading             │  │   │
+│       │                                                           │  │   │
+│       ├─ MessageList → 步骤条（只展示 tool call）                   │  │   │
+│       │                                                           │  │   │
+│       ├─ latestStreamingWriteFile(messages)                       │  │   │
+│       │     → onPreviewArtifact({..., auto:true}) ───────────────────┘   │
+│       │                                                                  │
+│       └─ useEffect → onThreadSnapshot({threadId, thread}) ───────────────┘
+└──────────────────────────────────────────────────────────────────────────┘
+```
+
+一句话：
+
+- **谁打开**：对话子组件决定「该不该开、开哪次交付」；  
+- **谁真正开面板**：页面壳；  
+- **内容怎么更新**：子组件持续上报 thread 快照 → 页面壳 store → 只有沙箱子树重渲染。
+
+---
+
+## 5. 职责划分：谁拥有什么状态
+
+### 5.1 页面壳必须拥有
+
+| 状态 / 能力 | 为什么必须在页面壳 |
+| --- | --- |
+| `sandboxArtifact` | 唯一预览目标；切节点时要清 |
+| `closedSandboxKeyRef` | 用户关过后的抑制；跨子组件生命周期 |
+| `sandboxThreadStore` | 流式内容通道；不能进大页面 state |
+| `closeSandbox()` | 切岗位 / 切节点 / 新会话统一入口 |
+| 唯一 `ArtifactFileDetail` | 避免双实例、关闭失效、深度异常 |
+
+### 5.2 对话子组件必须拥有
+
+| 状态 / 能力 | 作用 |
+| --- | --- |
+| `autoPreviewRunArmedRef`（armed） | 只有本轮用户发送后才允许自动开 |
+| `autoPreviewBaselineCallKeysRef`（baseline） | 忽略发送前已有的历史 write_file |
+| `activeWriteFilePreviewRef` | 记录当前打开的 previewKey / path / toolCallId |
+| `autoPreviewedArtifactKeyRef` | 同一次 identity 去重，避免每 chunk 重复上报 |
+| `latestStreamingWriteFile` | 从 streaming messages 探测可预览的 write |
+| `onThreadSnapshot` 上报 | 把 thread 喂给页面壳 |
+
+### 5.3 明确禁止
+
+1. 在 `PositionNodeChat` 内再挂一套 `ArtifactFileDetail`。  
+2. 让步骤条组件直接 `setOpen(true)` 作为岗位会商主路径（对照普通页可以，岗位会商不行）。  
+3. 把 `onThreadSnapshot` 落到 `PositionRoundtablePage` 的 `useState`。  
+4. 用「整个 threadId」做关闭抑制。  
+5. 用「path 相同」复用 `previewKey`。
+
+---
+
+## 6. 对接接口详解
+
+### 6.1 `PositionArtifactPreview`
+
+```ts
+type PositionArtifactPreview = {
+  threadId: string;          // 必填：LangGraph thread id
+  path: string;              // 必填：真实路径，或 write-file: 虚拟 URL，或临时文件名路径
+  name: string;              // 展示名（文件名）
+  mimeType: string | null;   // 如 text/markdown；帮助预览语言判断
+  previewKey?: string;       // 强烈建议：一次交付身份，推荐 `${messageId}:${toolCallId}`
+  auto?: boolean;            // true = 流式自动打开；缺省/false = 用户点击打开
+};
+```
+
+字段说明：
+
+| 字段 | 详细含义 |
+| --- | --- |
+| `threadId` | 沙箱用来匹配 `onThreadSnapshot` 的线程；也对关闭抑制键有贡献 |
+| `path` | 传给 `ArtifactFileDetail.filepath`。流式阶段通常是 `write-file:...` 虚拟 URL；落盘后的手动打开可以是真实 artifacts 路径 |
+| `name` | UI 展示用；临时名阶段可能是 `未命名文件.md` |
+| `mimeType` | 当 path 还不稳定时，帮助把语言判成 markdown/html，避免落成 TEXT |
+| `previewKey` | **一次交付的身份**。同一次 tool call 的 path 升级要保持不变；新的 tool call 必须变 |
+| `auto` | 自动打开才走关闭抑制；手动打开应清抑制 |
+
+### 6.2 `onPreviewArtifact(artifact)` —— 对话 → 页面
+
+页面壳 `handlePreviewArtifact` 当前逻辑顺序：
+
+1. 校验 `threadId`、`path`，缺则 toast 并 return。  
+2. 计算 `artifactKey = sandboxCloseKey(artifact)`。  
+3. 若 `artifact.auto === true` 且 `closedSandboxKeyRef.current === artifactKey` → **抑制，直接 return**。  
+4. 清 `closedSandboxKeyRef`（手动打开或新的自动打开）。  
+5. `ArtifactsContext.select(path, true)` + `setOpen(true)`。  
+6. 判断是否同一预览 / 是否仅 path upgrade：  
+   - `isSamePreview`：threadId + path + previewKey 全同 → 不重复 setState。  
+   - `isPathUpgrade`：previewKey 相同、path 不同 → 更新 artifact，**不要**再折叠右侧抽屉。  
+7. 若不是 same preview：  
+   - `setSandboxArtifact(artifact)`；  
+   - **同步** `sandboxArtifactRef.current = artifact`（关键！flush 会立刻读 ref）；  
+   - `sandboxSnapshotAppliedAtRef.current = 0`（允许立刻推首帧内容）。  
+8. 若 store 里已有别的 thread 快照，先 `publish(null)`。  
+9. 若 `latestNodeThreadSnapshotRef` 的 threadId 匹配，立刻 `queueSandboxThreadSnapshot`。  
+10. 非 path upgrade 时 `setRightPanelOpen(false)`。
+
+`sandboxCloseKey`：
+
+```ts
+if (artifact.previewKey) {
+  return `${artifact.threadId}:write:${artifact.previewKey}`;
+}
+return `${artifact.threadId}:${normalizePreviewArtifactPath(artifact.path)}`;
+```
+
+`ArtifactFileDetail` 的 React `key` 必须用这个 key：  
+**新 previewKey → 组件重挂 → 视觉上「清空再生成」。**
+
+### 6.3 `onThreadSnapshot({ threadId, thread })` —— 对话 → 页面
+
+每次 `thread` 引用变化（消息 chunk 到达）子组件都会调：
+
+```ts
+onThreadSnapshot?.({ threadId: activeThreadId, thread });
+```
+
+页面壳应：
+
+1. 计算 `signature = sandboxThreadSignature(thread)`（用 isLoading、messages 长度、最近 write_file 的 path/content 长度/尾部等拼签名，用于去重）。  
+2. 写入 `latestNodeThreadSnapshotRef`（即使沙箱还没开，打开瞬间也要用）。  
+3. 若当前没有打开的沙箱，或打开的沙箱 threadId 不一致 → **只更新 ref，不 publish**。  
+4. 若一致 → `queueSandboxThreadSnapshot`（前沿节流后 `store.publish`）。
+
+### 6.4 虚拟 URL 与正文读取
+
+流式阶段 path 形如：
+
+```text
+write-file:${sourcePath}?message_id=${messageId}&tool_call_id=${toolCallId}&language=markdown
+```
+
+`loadArtifactContentFromToolCall`：
+
+1. 解析 URL 的 `message_id`、`tool_call_id`；  
+2. 在 `thread.messages` 里找对应 AI message 的 tool call；  
+3. 返回 `toolCall.args.content`。
+
+结论：
+
+- 沙箱跟的是 **tool call 身份**，不是磁盘文件是否已经写完；  
+- 没有真实 path 也能显示正文；  
+- 临时文件名只影响展示名和语言猜测。
+
+### 6.5 对话子组件 → 页面壳的其它相关回调
+
+| 回调 | 用途 |
+| --- | --- |
+| `onPreviewArtifact` | 打开 / 更新沙箱 |
+| `onThreadSnapshot` | 推送流式 thread |
+| 页面壳 `closeSandbox` 传给 `ArtifactFileDetail.onClose` | 用户点关闭 |
+
+手动从流程图 / 产物列表打开时，也可以直接调 `handlePreviewArtifact`（通常不带 `auto`，或不带 previewKey）。
+
+---
+
+## 7. 打开沙箱的完整步骤
+
+### 7.1 武装（arm）：只有「本轮用户提交」才允许自动开
+
+在 `PositionNodeChat.handleSubmit` 真正 `sendMessage` 之前：
+
+```text
+activeWriteFilePreviewRef = null
+autoPreviewBaselineCallKeysRef = writeFileCallKeys(thread.messages)  // 历史 write 的 messageId:toolCallId
+autoPreviewRunArmedRef = true
+→ sendMessage(...)
+```
+
+发送失败要把 `armed` 设回 `false`。
+
+为什么要 baseline？
+
+线程里往往已经有上几次问答写过的 `write_file`。如果只看「messages 里有没有 write_file」，一提问就会把旧文件再打开一次。baseline 的含义是：**只有这次提交之后新出现的 tool call 才能自动开沙箱**。
+
+### 7.2 探测 `write_file`：不要等完整 path
+
+`write_file` 参数是一整段 JSON 流，**键顺序由模型决定**。
+
+| 模型吐参顺序 | 步骤条表现 | 错误做法的后果 |
+| --- | --- | --- |
+| path / description 先到，再 content | 很快显示描述和文件名 | 普通对话页常见；等 path 也能开 |
+| **content 先到，最后才 path** | 长时间只有「写入文件」，文件名很晚才出现 | 若硬等完整 path，沙箱会晚几十秒甚至一分钟 |
+
+岗位会商报告类 agent **经常是第二种**。
+
+`latestStreamingWriteFile` 规则：
+
+1. 倒序扫描 AI messages 的 `tool_calls`；  
+2. 工具名是 `write_file` 或 `str_replace`；  
+3. **有完整扩展名的 path**（`hasCompleteArtifactExtension`）→ 用真实路径；  
+4. **尚无可用 path，但 `write_file` 的 content 已有非空字符** → 临时文件名：  
+   - 正文头像 HTML → `未命名文件.html`  
+   - 否则 → `未命名文件.md`  
+5. `str_replace` 必须等真实 path（它改已有文件）；  
+6. 组装：  
+   - `key = messageId:toolCallId`  
+   - `path = write-file:虚拟URL`（write_file）或真实 path（str_replace）  
+   - `mimeType`：markdown 则 `text/markdown`
+
+为什么扩展名必须完整？
+
+流式 path 会经历 `/a/b/report.m` → `/a/b/report.md`。若在 `.m` 时就当真实文件打开，预览语言可能被永久判成 TEXT。
+
+### 7.3 上报 effect 的四个门闩
+
+自动上报 `onPreviewArtifact` 前必须同时满足：
+
+1. `thread.isLoading === true`  
+2. 探测到 streaming artifact，且其 key **不在** baseline  
+3. 已有 `previewThreadId`  
+4. `autoPreviewRunArmedRef === true`
+
+然后处理 previewKey：
+
+```text
+若与 activePreview 是同一次 tool call（含 tool-start 前缀兼容）
+  → 复用旧 previewKey   // 用于临时名 → 真实 path
+否则
+  → previewKey = 新的 messageId:toolCallId
+```
+
+去重键：
+
+```text
+`${previewThreadId}:${previewKey}:${sourcePath}`
+```
+
+把 `sourcePath` 算进去，是为了：**同 previewKey 下临时名变成真实 path 时，还要再报一次**（path upgrade），但不会每来一个 content chunk 都报。
+
+### 7.4 线程绑定竞态（不要误 disarm）
+
+首轮对话常出现：
+
+1. 用户发送（本地 draft threadId / 稍后 SDK 创建真实 id）；  
+2. 流已经开始、armed=true；  
+3. 会话 API 把 `node.threadId` 从 `null` 写成真实 id。
+
+这是「本节点绑定自己的新线程」，**不是**切节点。若绑定 effect 无脑清空 armed / baseline，首轮会永远开不了沙箱。
+
+正确：识别 `isOwnThreadBinding`（同 nodeKey、旧 threadId 为空、新 threadId 等于当前 boundThreadId）时 **直接 return，不清 armed**。
+
+### 7.5 path upgrade（改名）≠ 第二次交付
+
+同一次 tool call：
+
+```text
+T1  content 到达 → path=未命名文件.md, previewKey=msg:tc1 → 打开
+T2  真实 path 到达 → path=/mnt/.../报告.md, previewKey=msg:tc1 → 只改名
+```
+
+页面壳看到相同 previewKey、不同 path → `isPathUpgrade`：
+
+- 更新 `sandboxArtifact`；  
+- **不**重挂（React key 仍基于 previewKey）；  
+- **不**再折叠右侧抽屉。
+
+### 7.6 同路径二次写入（重新生成）
+
+同一次问答里模型可能：
+
+```text
+1) write_file → 步骤条「写入文件」→ 打开沙箱
+2) 再 write_file 同 path，description=「重新生成优化版…」
+```
+
+这是**两次 tool call**，必须两个 previewKey。  
+若错误地「path 相同就复用 previewKey」：
+
+- 步骤条出现第二条；  
+- 沙箱 React key 不变；  
+- 用户看到「重新生成了，但沙箱没变化」。
+
+正确：身份只看 tool call。
+
+### 7.7 时序总图（content-first）
+
+```text
+T0    用户发送 → armed=true，拍 baseline
+T1    步骤条出现「写入文件」（尚无 path）
+T1+   args.content 首字符到达 → 临时名打开沙箱，源码开始滚动
+      … store 约每 160ms 推一次 thread 快照 …
+T2    args.path 拼完整（含 .md）→ path upgrade，标题改真实文件名（不重挂）
+T3    write 结束 / isLoading=false → 自动切 Markdown 预览
+```
+
+### 7.8 时序总图（同轮二次写入）
+
+```text
+T1  write_file#1 → previewKey=msg:tc1 → 打开沙箱 A
+T2  #1 结束（可能短暂切预览）
+T3  write_file#2（同 path，新 description）→ previewKey=msg:tc2
+    → key 变 → 组件重挂清空 → 跟 #2 重新流式
+```
+
+---
+
+## 8. 关闭沙箱的完整步骤
+
+### 8.1 用户手动关闭
+
+`closeSandbox()` 应做：
+
+1. `closedSandboxKeyRef = sandboxCloseKey(current)` —— 抑制**这一次**自动再开；  
+2. 关闭 `ArtifactsContext.open`（若开着）；  
+3. 清节流定时器、pending 快照；  
+4. `sandboxSnapshotAppliedAtRef = 0`；  
+5. `sandboxArtifactRef = null` + `setSandboxArtifact(null)`；  
+6. `sandboxThreadStore.publish(null)`。
+
+抑制与 path upgrade 的关系：
+
+- 关掉临时名面板后，同一次 tool call 升级真实 path **仍被抑制**（同一 previewKey）——符合「用户不要看这次」；  
+- 下一次新的 `write_file`（新 previewKey）**可以**再自动开。
+
+### 8.2 场景切换时强制关闭
+
+以下操作应先调用 `closeSandbox()`，避免串台：
+
+- 切岗位；  
+- 切节点；  
+- 切收口阶段；  
+- 新建会话；  
+- 切换历史会话。
+
+是否写入 `closedSandboxKeyRef` 可按产品决定；至少必须清面板和 store。
+
+### 8.3 错误的抑制粒度（历史坑）
+
+若做成「关过一次就整个 thread 不再自动开」：
+
+- 第一次实时开正常；  
+- 用户关掉；  
+- 再问一次 → 同 thread 被永久抑制 → 看起来像「第二次不实时 / 要等生成完」。
+
+正确粒度：**单次交付的 `sandboxCloseKey`（含 previewKey）**。
+
+---
+
+## 9. 步骤条与沙箱的关系
+
+### 9.1 步骤条从哪来
+
+步骤条由 `MessageList` → `message-group.tsx` 渲染 tool call：
+
+- 标题：优先 `args.description`；没有则 i18n 兜底「写入文件」；  
+- 子行：有 `args.path` 才显示路径；  
+- 普通对话页还会在「有 path + autoOpen」时自己 `select/setOpen`。
+
+岗位会商里，步骤条**仍然只负责展示**；打开沙箱走 `onPreviewArtifact`，不要让两套逻辑抢。
+
+### 9.2 对照表
+
+| 你看到的步骤条 | 含义 | 沙箱应处于 |
+| --- | --- | --- |
+| 仅「写入文件」，无路径 | tool call 已开始；path/description 可能还没流到 | **应已打开**（临时名），源码在滚 |
+| 「写入文件」+ 路径 | path 已可用 | 已打开；若刚从临时名升级则只改名 |
+| 带自定义 description 的标题 + 路径 | 模型给了 description | 同上 |
+| 第二条「重新生成…」+ 同路径 | 新的 write_file（新 toolCallId） | **应重挂**并重新流式 |
+| 顶部「正在生成，完成后自动预览」 | 仍在 code 视图 | 正常，等 isLoading 结束切预览 |
+| 生成结束，出现文件卡片 / present_files | 工具结果已落 | 通常已是预览模式；可手动再点开 |
+
+### 9.3 常见误解
+
+**误解 1：**「步骤条出现文件名 = 打开沙箱的正确时机」  
+→ 错。那是 path 到达的时机。content-first 时正确打开时机更早：content 首字节 / 工具调用已开始。
+
+**误解 2：**「步骤条还在写『写入文件』，沙箱却开了，是 bug」  
+→ 通常不是。两边数据源相同，但沙箱允许无 path 打开，步骤条标题可能还没 description。
+
+**误解 3：**「等生成完从编辑切预览 = 沙箱打开晚了」  
+→ 错。那是 `ArtifactFileDetail` 的 viewMode 策略。
+
+---
+
+## 10. 流式内容如何进入沙箱（性能关键）
+
+### 10.1 为什么不能用页面 `useState` 存线程快照
+
+错误写法：
+
+```ts
+setSandboxThreadSnapshot(snapshot) // 页面级 useState
+```
+
+后果：
+
+- 消息 chunk 约每 30ms 一次，节流后仍约 6 次/秒；  
+- 每次都重渲染整页：任务卡、意图结果、流程图、节点对话……；  
+- 主线程占满 → 消息列表停绘、沙箱冻住；  
+- 纯尾随 `setTimeout(160)` 会被饿死，十几秒不 flush。
+
+这同时解释了两个历史现象：
+
+1. 「沙箱打开了但内容不更新」；  
+2. 「修完节流后整页更卡、消息也不实时」——因为节流终于开始真正 setState 了。
+
+### 10.2 正确做法：外部 store + 子树订阅
+
+```ts
+createSandboxThreadStore()
+  subscribe / getSnapshot / publish
+
+SandboxThreadProvider
+  useSyncExternalStore(store.subscribe, store.getSnapshot)
+  → ThreadContext.Provider value={{ thread, isMock:false }}
+  → ArtifactFileDetail
+```
+
+页面壳本身**不**因 snapshot 变化而重渲染；只有 Provider 及其子树重渲染。
+
+### 10.3 节流必须是前沿（leading-edge）
+
+`SANDBOX_SNAPSHOT_MIN_INTERVAL_MS = 160`：
+
+```text
+queue(snapshot):
+  pending = snapshot
+  if 距上次 publish >= 160ms:
+      立刻 flush（同步 publish）
+  else:
+      若没有在途 timer，则 setTimeout(剩余时间) 做补尾
+flush:
+  清 timer
+  校验 pending.threadId === sandboxArtifactRef.threadId
+  publish(pending)
+```
+
+**不要**改回：
+
+```ts
+if (timer != null) return;
+timer = setTimeout(flush, 160);
+```
+
+那是纯尾随；忙主线程下会假死。
+
+### 10.4 signature 去重
+
+`sandboxThreadSignature` 用最近 write_file 的 path、content 长度、content 尾 32 字等拼签名。  
+store.publish 时若 threadId+signature 未变，则不通知订阅者，减少无效渲染。
+
+### 10.5 打开瞬间的首帧
+
+`handlePreviewArtifact` 里往往会立刻 `queueSandboxThreadSnapshot(latestSnapshot)`。  
+此时 React 的 `setSandboxArtifact` 可能还没提交，若 flush 只读旧的 `sandboxArtifactRef`，会因 threadId 不匹配把首帧丢掉。
+
+所以打开新预览时必须：
+
+```ts
+sandboxArtifactRef.current = artifact; // 同步
+sandboxSnapshotAppliedAtRef.current = 0;
+```
+
+---
+
+## 11. 与普通对话页的对照
+
+| 点 | 普通对话页 | 岗位会商 |
+| --- | --- | --- |
+| 谁触发打开 | `message-group` 内 `artifacts.select` | 子组件 `onPreviewArtifact` → 页面壳 |
+| 是否要求 path | 是（有 path 才自动开） | 否（write_file + content 可临时名开） |
+| thread 从哪来 | 同树 ThreadContext | `onThreadSnapshot` + 外部 store |
+| 关闭抑制 | 主要靠 ArtifactsContext / 用户操作 | `closedSandboxKeyRef` 按 previewKey |
+| 同 path 重写 | 依赖新的 tool call / 选择逻辑 | **必须**新 previewKey 以重挂 |
+| 结束后切预览 | ArtifactFileDetail 同一套 | 同一套 |
+
+对齐目标是**用户感知一致**，不是代码路径完全相同。
+
+普通对话页自动开的核心条件（对照用）：
+
+```ts
+artifacts && isLoading && isLast && autoOpen && autoSelect && path && !result
+```
+
+它也要求 path，所以 content-first 时普通页同样会偏晚——只是很多主聊天示例 agent 先吐 path，观感更好。岗位会商报告 agent 更常 content-first，所以必须做临时名提前开。
+
+---
+
+## 12. 重做页面时的必守规则
+
+按优先级：
+
+1. **流式 thread 快照禁止进页面级 `useState`** → 用 store + `useSyncExternalStore`。  
+2. **节流用前沿 + 补尾**，不要纯尾随 timer。  
+3. **不要等完整 path 才开**；`write_file` + content 即可临时名打开。  
+4. **扩展名完整前不要把 path 当最终 path**。  
+5. **previewKey 按 tool call，不按 path**。  
+6. **打开时同步写 `sandboxArtifactRef`，并重置节流时间戳**。  
+7. **主路径扫描 `thread.messages`，不要只靠 `onToolStart`**。  
+8. **path upgrade 保持 previewKey，不要当第二次交付**。  
+9. **关闭抑制按 sandboxCloseKey，不要按整 thread**。  
+10. **沙箱单例在页面壳；子组件只上报**。  
+11. **本节点 threadId 回写不要 disarm**。  
+12. **「结束后才切预览」不要当打开 bug 去「修」掉共享组件**，除非产品明确要求边生成边渲染 Markdown（需单独评估性能）。
+
+---
+
+## 13. 历史问题与根因（务必读）
+
+下面每个都在真实联调里出现过。重做时若踩中，优先回来对照。
+
+### 13.1 沙箱要等文件名出来才开（晚几十秒）
+
+**现象：** 步骤条早就「写入文件」，沙箱很晚才开；普通对话页对比显得「实时」。  
+
+**根因：** 探测逻辑硬等完整 `path`；而该 agent 先流 `content`、最后才流 `path`。  
+
+**修复：** content 首批字符即可用临时名打开；path 到了再 upgrade。
+
+### 13.2 沙箱打开了，内容冻住，生成完才灌满
+
+**现象：** 面板开了，但里面一直是空/旧内容；日志里 queue 很多，flush 很少。  
+
+**根因：** 纯尾随 160ms 定时器在忙主线程下被饿死。  
+
+**修复：** 前沿节流——到期就在流回调里同步 flush。
+
+### 13.3 修完「内容更新」后，整页卡顿、消息也不实时
+
+**现象：** 沙箱开始更新了，但页面更卡，消息列表也「攒到最后刷」。  
+
+**根因：** flush 走的是页面 `useState`，每 160ms 整页重渲染。以前 timer 饿死时反而「不卡」。  
+
+**修复：** 快照改外部 store，只让沙箱子树订阅。
+
+### 13.4 第二次「重新生成」步骤有了，沙箱不变
+
+**现象：** 同轮第二条二条 write 步骤，沙箱仍显示第一次完整结果。  
+
+**根因：** 用「path 相同」复用了第一次 previewKey，React key 不变，组件不重挂。  
+
+**修复：** previewKey 只按 tool call；同 path 新 call 必须新 key。
+
+### 13.5 第一次实时，关掉后再问就不实时
+
+**现象：** 关过沙箱后，下一轮要等生成完才开，或不开。  
+
+**根因：** 抑制绑在整个 threadId，或把 path upgrade / 新 call 误判成同一次。  
+
+**修复：** 抑制键 = `sandboxCloseKey(previewKey)`；仅抑制那一次交付。
+
+### 13.6 首轮永远不开
+
+**现象：** 新建节点第一次提问，armed 后很快又不满足条件。  
+
+**根因：** `node.threadId` 从 null 回写真实 id 时，绑定 effect 误 disarm。  
+
+**修复：** `isOwnThreadBinding` 时不清 armed。
+
+### 13.7 预览变成纯文本
+
+**现象：** 明明是 md，却按 TEXT 打开。  
+
+**根因：** 在 `.m` 阶段就当完整 path；或临时名没有 `.md` / 没传 language、mimeType；或 path 带空格。  
+
+**修复：** `hasCompleteArtifactExtension`；临时名带扩展名；URL 加 `language=markdown`；path trim。
+
+### 13.8 依赖 onToolStart，线上偶发不开
+
+**现象：** 本地偶发正常，联调经常不开。  
+
+**根因：** 后端 StreamBridge / worker 可能过滤 tools/events 类 stream mode。  
+
+**修复：** 主路径必须是 messages 里渐进出现的 `tool_calls`；onToolStart 只能当补充。
+
+---
+
+## 14. 排障手册（按症状）
+
+排障时建议先看 Chrome Performance / React 重渲染是否整页抖，再看消息里 tool_calls 的 args 是 path-first 还是 content-first。
+
+### 14.1 沙箱开得很晚
+
+检查顺序：
+
+1. `latestStreamingWriteFile` 是否仍要求完整 path？  
+2. armed 是否被 threadId 回写清掉？  
+3. 是否命中 `closedSandboxKey`？  
+4. 新 call 是否被 baseline 当成历史？  
+5. `previewThreadId` 是否为空（线程还没绑上）？
+
+### 14.2 打开了但内容空白 / 冻住
+
+1. 快照是否进了页面 useState？  
+2. 节流是否纯尾随？  
+3. `SandboxThreadProvider` 是否拿到带 messages 的 thread？  
+4. 虚拟 URL 的 message_id / tool_call_id 是否对得上？  
+5. 打开时 `sandboxArtifactRef` 是否同步？（首帧是否被 drop）  
+6. signature 是否因实现错误一直不变，导致 publish 被去重？
+
+### 14.3 整页卡、消息列表也不实时
+
+1. 搜页面壳是否还有 `setSandboxThreadSnapshot` / 类似大对象 state。  
+2. 是否在每 chunk `console.debug` 打大对象（DevTools 打开时更卡）。  
+3. 是否错误地让页面壳订阅了 store（页面壳不应 `useSyncExternalStore` 这份 store；只有 Provider 订）。
+
+### 14.4 重新生成不刷新
+
+1. 第二次 write 的 toolCallId 是否变了？  
+2. previewKey 是否仍用 path 复用？  
+3. `ArtifactFileDetail` 的 `key=` 是否基于 sandboxCloseKey/previewKey？
+
+### 14.5 关后再问异常
+
+1. 打印 `closedSandboxKeyRef` 与新 artifact 的 sandboxCloseKey。  
+2. 确认新一轮 send 时 armed/baseline 已重置。  
+3. 确认抑制不是整 thread。
+
+### 14.6 语言 / 预览模式不对
+
+1. 看打开时的 path / mimeType / language 查询参数。  
+2. 确认不是在扩展名不完整时打开。  
+3. 确认「源码→预览」发生在 isLoading false 之后（属正常）。
+
+---
+
+## 15. 对接自测清单
+
+重做页面后至少跑完：
+
+### 功能
+
+- [ ] 首轮：步骤条「写入文件」出现时，沙箱是否已开并开始出字？  
+- [ ] content-first agent：无文件名阶段是否也能开？  
+- [ ] path 到达后：是否只改名、不整页闪、不重挂？  
+- [ ] 同轮第二次同路径 write：是否清空并重新流式？  
+- [ ] 结束后是否自动切 Markdown 预览？  
+- [ ] 手动点步骤条路径 / 产物卡片：能否打开正确文件？  
+
+### 关闭与抑制
+
+- [ ] 流式中手动关闭：本次是否不再自动弹？  
+- [ ] 关闭后再发一轮新问题：是否仍可自动开？  
+- [ ] path upgrade 是否不会绕过「用户刚关闭」的抑制？  
+
+### 场景切换
+
+- [ ] 切节点：沙箱关闭，旧内容不残留。  
+- [ ] 切岗位：同上。  
+- [ ] 新建会话 / 切历史：同上。  
+
+### 性能
+
+- [ ] 流式中消息列表是否实时出字？  
+- [ ] 页面是否明显掉帧 / 卡死？  
+- [ ] React DevTools 中，大页面壳是否在每 160ms 整页 update？（不应）
+
+---
+
+## 16. 最小接线示例
+
+### 16.1 页面壳（示意）
+
+```tsx
+const [sandboxArtifact, setSandboxArtifact] = useState<PositionArtifactPreview | null>(null);
+const sandboxArtifactRef = useRef<PositionArtifactPreview | null>(null);
+const closedSandboxKeyRef = useRef<string | null>(null);
+const latestNodeThreadSnapshotRef = useRef<SandboxThreadSnapshot | null>(null);
+const store = useMemo(createSandboxThreadStore, []);
+// pending + timer + appliedAt 用于前沿节流（见 PositionRoundtablePage）
+
+function handlePreviewArtifact(artifact: PositionArtifactPreview) {
+  if (!artifact.threadId || !artifact.path) return;
+  const key = sandboxCloseKey(artifact);
+  if (artifact.auto && closedSandboxKeyRef.current === key) return;
+  closedSandboxKeyRef.current = null;
+
+  artifactsCtx?.select(artifact.path, true);
+  artifactsCtx?.setOpen(true);
+
+  const prev = sandboxArtifactRef.current;
+  const isSame =
+    prev?.threadId === artifact.threadId &&
+    prev.path === artifact.path &&
+    prev.previewKey === artifact.previewKey;
+  const isPathUpgrade =
+    !isSame &&
+    Boolean(artifact.previewKey) &&
+    prev?.threadId === artifact.threadId &&
+    prev.previewKey === artifact.previewKey;
+
+  if (!isSame) {
+    sandboxArtifactRef.current = artifact; // 必须同步
+    setSandboxArtifact(artifact);
+    sandboxSnapshotAppliedAtRef.current = 0;
+  }
+
+  if (store.getSnapshot()?.threadId !== artifact.threadId) {
+    store.publish(null);
+  }
+  const latest = latestNodeThreadSnapshotRef.current;
+  if (latest?.threadId === artifact.threadId) {
+    queueSandboxThreadSnapshot(latest);
+  }
+  if (!isPathUpgrade) setRightPanelOpen(false);
+}
+
+function handleNodeThreadSnapshot(snapshot: { threadId: string; thread: BaseStream<AgentThreadState> }) {
+  const next = { ...snapshot, signature: sandboxThreadSignature(snapshot.thread) };
+  latestNodeThreadSnapshotRef.current = next;
+  if (sandboxArtifactRef.current?.threadId !== snapshot.threadId) return;
+  queueSandboxThreadSnapshot(next);
+}
+
+function closeSandbox() {
+  if (sandboxArtifactRef.current) {
+    closedSandboxKeyRef.current = sandboxCloseKey(sandboxArtifactRef.current);
+  }
+  // clear timer / pending / appliedAt
+  sandboxArtifactRef.current = null;
+  setSandboxArtifact(null);
+  store.publish(null);
+  artifactsCtx?.setOpen(false);
+}
+
+// 渲染
+{sandboxArtifact && (
+  <SandboxThreadProvider
+    store={store}
+    threadId={sandboxArtifact.threadId}
+    fallbackThread={stub}
+  >
+    <ArtifactFileDetail
+      key={sandboxCloseKey(sandboxArtifact)}
+      filepath={sandboxArtifact.path}
+      threadId={sandboxArtifact.threadId}
+      mimeType={sandboxArtifact.mimeType}
+      onClose={closeSandbox}
+      allowVirtualMarkdownEdit
+    />
+  </SandboxThreadProvider>
+)}
+```
+
+### 16.2 对话子组件（示意）
+
+```tsx
+// send 前
+activeWriteFilePreviewRef.current = null;
+autoPreviewBaselineCallKeysRef.current = writeFileCallKeys(thread.messages);
+autoPreviewRunArmedRef.current = true;
+await sendMessage(...);
+
+// 探测
+const streaming = thread.isLoading ? latestStreamingWriteFile(thread.messages) : null;
+const next =
+  streaming && !autoPreviewBaselineCallKeysRef.current.has(streaming.key)
+    ? streaming
+    : null;
+
+useEffect(() => {
+  if (!thread.isLoading || !next || !previewThreadId || !autoPreviewRunArmedRef.current) return;
+
+  // previewKey：同 tool call 复用，否则用 next.key
+  // artifactKey = threadId:previewKey:sourcePath 去重
+  onPreviewArtifact?.({
+    threadId: previewThreadId,
+    path: next.path,
+    name: next.name,
+    mimeType: next.mimeType,
+    previewKey,
+    auto: true,
+  });
+}, [next, previewThreadId, thread.isLoading, onPreviewArtifact]);
+
+useEffect(() => {
+  onThreadSnapshot?.({ threadId: activeThreadId, thread });
+}, [activeThreadId, thread, onThreadSnapshot]);
+```
+
+**强烈建议：** 探测 / armed / baseline / 临时名逻辑直接复用或抽取自 `PositionNodeChat`，不要从零重写。
+
+---
+
+## 17. 关键代码索引
+
+| 主题 | 位置 |
+| --- | --- |
+| 临时名 / 完整扩展名 / latestStreamingWriteFile | `PositionNodeChat.tsx` 中 `provisionalWriteFilePath`、`hasCompleteArtifactExtension`、`latestStreamingWriteFile` |
+| armed / baseline / 上报 effect | `PositionNodeChat.tsx` `handleSubmit` + streaming preview `useEffect` |
+| 同 tool call 判断 / 二次写入重挂 | 同上，`isSameToolCall` / `previewKey` |
+| 线程绑定保护 | `PositionNodeChat.tsx` node binding `useEffect` 中 `isOwnThreadBinding` |
+| sandboxCloseKey / store / 前沿节流 | `PositionRoundtablePage.tsx` `sandboxCloseKey`、`createSandboxThreadStore`、`queueSandboxThreadSnapshot` |
+| 打开 / path upgrade / 抑制 | `PositionRoundtablePage.tsx` `handlePreviewArtifact` |
+| 关闭 | `PositionRoundtablePage.tsx` `closeSandbox` |
+| 虚拟 URL 读 content | `core/artifacts/loader.ts` `loadArtifactContentFromToolCall` |
+| 源码/预览切换 | `artifact-file-detail.tsx` 中 `viewMode` + `thread.isLoading` |
+| 普通页步骤条自动开 | `message-group.tsx` `write_file` 分支 |
+
+相关提交（背景）：
+
+- `fix(frontend): 岗位会商沙箱在 write_file 流式阶段实时打开并刷新`  
+  — 临时名打开、外部 store、前沿节流  
+- `fix(frontend): 同路径二次 write_file 时重挂岗位会商沙箱`  
+  — previewKey 按 tool call，禁止按 path 复用  
+
+---
+
+## 18. 术语表
+
+| 术语 | 含义 |
+| --- | --- |
+| armed | 本轮用户发送后，允许自动打开沙箱的开关 |
+| baseline | send 前已有的 write tool call 集合，用于忽略历史产物 |
+| previewKey | 一次交付的稳定身份，推荐 `messageId:toolCallId` |
+| sandboxCloseKey | 关闭抑制键，同时用作 `ArtifactFileDetail` 的 React key |
+| provisional path / 临时名 | 尚无真实 path 时的 `未命名文件.md` / `.html` |
+| path upgrade | 同 previewKey 下临时名升级为真实 path |
+| sandboxThreadStore | 流式线程外部 store，避免整页重渲染 |
+| write-file: URL | 用 message_id + tool_call_id 定位流式 content 的虚拟路径 |
+| leading-edge throttle / 前沿节流 | 到期立即在回调里 publish，而不是只挂尾随 timer |
+| content-first / path-first | 模型流式 JSON 参数时 content 与 path 哪个先到 |
+| isOwnThreadBinding | 本节点把自己的新 threadId 写回 props，不是切节点 |
+
+---
+
+## 附录 A：给对接同学的一页纸摘要
+
+1. 页面壳只挂一个沙箱；子组件只调用 `onPreviewArtifact` / `onThreadSnapshot`。  
+2. 自动打开时机 ≈ 步骤条出现「写入文件」时，而不是出现文件名时。  
+3. `write_file` 可以没有 path：临时名打开，path 到了再改名。  
+4. 流式 thread 进外部 store，进页面 state 会卡死。  
+5. 节流要前沿；previewKey 看 tool call；关闭抑制看 sandboxCloseKey。  
+6. 同路径重新生成 = 新 previewKey = 沙箱重挂。  
+7. 出问题先对照第 13、14 节，再看代码索引第 17 节。

frontend-web/docs/roundtable-dag-orchestration.md

@@ -0,0 +1,610 @@
+# 圆桌 DAG 编排 + 并行执行显示 —— 分步实现需求文档
+
+> 目标读者：实现本功能的前端 / 后端工程师。
+> 本文是**可逐步落地**的需求 + 设计文档，每个 Phase 都能独立交付、独立验收。
+
+---
+
+## 0. 背景与目标
+
+### 0.1 现状
+
+Step 2 圆桌目前有两种编排模式（`orchestrationMode`，见 `hooks/useStep2Orchestration.ts`）：
+
+- **`free`（自由模式）**：总控（leader）自由决定派活给谁，`runOrchestration` 循环驱动。
+- **`chain`（线性链条）**：用户把席位排成一条**线性**链 `A → B → C`，`runChainOrchestration` 按顺序逐个派活，最后总控收口。链路用 `DispatchChainModal.tsx` 的**横向流程图**展示（总控 → 席位1 → 席位2 → … → 共识 → 报告）。
+
+链条数据现在只是一个**有序数组** `selectedAgents`（线性），节点状态类型见 `lib/job-types.ts`（`ChainNodeState = pending | active | done`）。
+
+### 0.2 目标（本次新增）
+
+1. **DAG 编排**：用户可视化指定**智能体之间的直接依赖关系**——有的串行（`A → B → C`），有的并行（`A B C` 同时跑）。编排结果是一张**流程图（DAG）**。
+2. **并行执行**：DAG 里同一层（互不依赖）的智能体**并行**跑，墙钟时间从「串行求和」降到「并行取最慢」。
+3. **并行禁止写文件**：并行的智能体**禁用文件写入 / 沙箱命令**，避免它们同时打开沙箱互相打架。产物以消息正文交付；落文件留给串行 / 收口阶段。
+4. **并行高性能显示**：并行时收起左侧、顶部头像条切换、主区同时显示 2 个智能体的消息流，其余**只接流不渲染**，避免页面卡死。
+
+### 0.3 设计总原则
+
+- **复用** 现有 special run / leader run / rollback 抢占 / 轻量交付状态接口（`GET /threads/{id}/last-ai-message`），不另起炉灶。
+- **线性链是 DAG 的特例**：`chain` 模式可平滑迁移成"每层 1 个节点"的 DAG，老数据不破坏。
+- **分层（Stage）优先于自由连线**：编辑交互首选「分层」模型（每个 stage 放若干并行席位，stage 间串行），实现成本低、覆盖 95% 的"串 / 并"诉求；自由连线画布作为后续可选增强（见 §2.3）。
+
+### 0.4 已确认的设计决策（✅ 本期按这些实现）
+
+> 以下三项已与需求方确认锁定，实现时直接按此，不再二选一。
+
+1. **✅ 编排模型 = 分层 Stage**：本期只做分层（每个 stage 放若干并行席位、stage 间串行）。**自由连线画布本期不做**，仅在数据模型层预留（§1.2）以免将来返工。
+2. **✅ 并行跳过 leader、前端直派**：DAG 由用户显式指定，执行时前端**直接**对 stage 内席位发起 special run，**不**每个 stage 再跑一轮总控派活；只在最后 `finalSynthesis` 跑一轮 leader 综合（即 §3.2 的方案 B）。
+3. **✅ 主区固定 2 列，窄屏降 1 列**：并行时主区最多并排显示 2 个被选中智能体的消息流；窄屏（断点见 §5.3）降为 1 列 + 头像条横向滚动。不做 3+ 列。
+
+---
+
+## 1. 数据模型
+
+### 1.1 DAG 的「分层」表示（推荐，主模型）
+
+把 DAG 表示成**有序的 stage 列表**，每个 stage 内的席位并行、stage 之间串行：
+
+```ts
+// lib/dag-types.ts （新建）
+
+/** 一个并行批次：stage 内所有席位并行执行。 */
+export interface OrchestrationStage {
+  /** stage 稳定 id（拖拽重排 / diff 用）。 */
+  id: string;
+  /** 本 stage 并行执行的席位（agent_id 列表）。1 个 = 退化为串行节点。 */
+  agentIds: string[];
+}
+
+/** 用户编排出的执行计划。stages 顺序即串行顺序。 */
+export interface OrchestrationPlan {
+  /** 编排模式标识，持久化进 step2。 */
+  mode: "dag";
+  /** 串行执行的批次；每批内并行。 */
+  stages: OrchestrationStage[];
+  /** 收口：是否在所有 stage 完成后由总控综合（默认 true）。 */
+  finalSynthesis: boolean;
+}
+```
+
+- **串行** `A → B → C` = `stages: [{agentIds:[A]}, {agentIds:[B]}, {agentIds:[C]}]`。
+- **并行** `A B C` = `stages: [{agentIds:[A,B,C]}]`。
+- **混合** `A →(B C)→ D` = `stages: [{[A]}, {[B,C]}, {[D]}]`。
+
+> 为什么用分层而不是「邻接表 / 边」：执行调度本就是「拓扑分批」，分层就是分批的结果，前端不必再做拓扑排序，也天然避免环；编辑器交互更直观（拖卡片进 stage）。真正的自由连线 DAG 见 §2.3（可选）。
+
+### 1.2 通用 DAG 表示（§2.3 自由连线时才需要）
+
+若将来做自由连线画布，再引入边表示，并在执行前做一次**拓扑排序 → 分层**，落回 §1.1 的 stages 结构给调度器用：
+
+```ts
+export interface DagEdge { from: string; to: string }   // from 完成后才能跑 to
+export interface DagGraph { nodes: string[]; edges: DagEdge[] }
+// 执行前：toposortToStages(graph) -> OrchestrationStage[]
+```
+
+### 1.3 持久化
+
+- 复用 `roundtable_drafts.step2` JSON（见后端 `app.gateway.routers` roundtable-drafts + `hooks/useStep2Orchestration.ts` 里对 `step2` 的读写）。
+- 在 `step2` 增加字段：`orchestrationPlan: OrchestrationPlan | null`。
+- `orchestrationMode` 扩展为 `"free" | "chain" | "dag"`；`chain` 旧数据读取时即时转换为单节点-stage 的 `dag`（兼容层，不改老 draft）。
+
+### 1.4 校验（纯函数，可单测）
+
+`lib/dag-types.ts` 内提供：
+
+```ts
+validatePlan(plan: OrchestrationPlan, selectedAgentIds: string[]): {
+  ok: boolean;
+  errors: string[];   // 面向用户的中文提示
+}
+```
+
+校验项：
+- 每个 `agentId` 必须在本次选定席位 `selectedAgents` 内（防止编排了不存在的席位 → 复用后端 `_partition_dispatch` 同思路的"必须在 roster 内"）。
+- 不允许空 stage；不允许同一席位出现在多个 stage（一个席位只跑一次）。
+- 至少 1 个 stage。
+- （可选）单 stage 并行度上限提示（如 > 6 并行给 warning：远程模型并发 + 沙箱压力）。
+
+---
+
+## 2. 编排编辑器（流程图构建）交互
+
+### 2.1 入口与整体布局
+
+- 在 Step 2 顶部模式切换里新增 **「依赖编排」**（`dag`）模式（与现有 自由 / 链条 并列）。
+- 选择 `dag` 后弹出 / 进入**编排编辑器**（复用 Dialog 大弹窗，参考 `DispatchChainModal` 的尺寸 `w-[94vw] max-w-[1240px]`）。
+
+### 2.2 推荐交互：分层（Stage）编辑器（Phase 2 实现）
+
+```
+┌ 依赖编排 ───────────────────────────────────────── [校验✓] [保存] ┐
+│  可选席位（点/拖加入某个 stage）                                   │
+│  [情报收集] [环境评估] [方案设计] [风险审查] [执行规划] [前端实现]  │
+│ ─────────────────────────────────────────────────────────────── │
+│  Stage 1（并行）              Stage 2（并行）       Stage 3        │
+│  ┌──────────┐  ─────▶  ┌──────────┐ ┌────────┐ ─▶ ┌──────────┐    │
+│  │ 情报收集 │          │ 方案设计 │ │风险审查│    │ 执行规划 │    │
+│  └──────────┘          └──────────┘ └────────┘    └──────────┘    │
+│   [＋ 拖席位到此]        [＋]                       [＋]            │
+│  [＋ 新建 Stage（串在最后）]                                       │
+│ ─────────────────────────────────────────────────────────────── │
+│  说明：同一 Stage 内的席位会**并行**执行；Stage 之间**串行**       │
+│  （后一个 Stage 能看到前面所有 Stage 的交付摘要）。                │
+└───────────────────────────────────────────────────────────────────┘
+```
+
+交互要点：
+- **加入 stage**：从顶部可选席位**拖拽**到某个 stage，或点席位 →「加入 Stage N」。
+- **移动 / 重排**：席位可在 stage 间拖动；stage 可整体左右拖动重排（改串行顺序）。
+- **删除**：席位 / 空 stage 可删。
+- **并行度提示**：stage 内 ≥2 席位即标「并行」徽标；过多给 warning。
+- **实时校验**：`validatePlan` 实时跑，错误在顶部红条提示，「保存」在校验通过前禁用。
+- **预览流程图**：编辑区下方实时渲染只读流程图缩略（复用 §7 的 DAG 流程图组件）。
+
+> 拖拽可用现成轻量方案（HTML5 DnD 或 `@dnd-kit`，看项目是否已有依赖；没有就先用「点选 + 加入/移出按钮」的无拖拽版，Phase 2 先上无拖拽、Phase 2.5 再加拖拽）。
+
+### 2.3 可选增强：自由连线画布（后续，非本期必须）
+
+- 节点自由摆放 + 拉线建边 → `DagGraph`（§1.2）。
+- 实现成本高（画布 / 连线 / 命中检测 / 自动布局），且分层模型已覆盖绝大多数诉求。**本期不做**，仅在数据模型上预留 §1.2，避免将来返工。
+
+### 2.4 验收（Phase 2）
+
+- 能拖 / 点把席位分配到多个 stage，保存进 `step2.orchestrationPlan`。
+- 刷新 / 重进 draft 能恢复编排。
+- 非法编排（空 stage / 席位重复 / 席位不在 roster）有明确中文提示且无法保存。
+
+---
+
+## 3. 执行调度（前端编排循环 + 后端复用）
+
+### 3.1 新增 `runDagOrchestration`（`useStep2Orchestration.ts`）
+
+与现有 `runOrchestration` / `runChainOrchestration` 并列，逻辑：
+
+```
+for (stageIndex, stage of plan.stages):
+  if isStale() break               // 复用现有 epoch 抢占（人工干预/暂停）
+  // 1) 总控按本 stage 的席位并行派活（一轮 leader，dispatched = stage.agentIds）
+  //    —— 或跳过 leader，前端直接对 stage 内每个席位发起 special run（见 3.2）
+  // 2) 并行跑 stage 内所有席位
+  await Promise.all(stage.agentIds.map(seat =>
+        streamMultiAgent({ agentType:"special", agentName:seat,
+                           newMessage: buildStageTask(seat, plan, stageIndex),
+                           parallelNoFile: stage.agentIds.length > 1,  // §4
+                           ... })))
+  // 3) 等本 stage 全部 ✅（Promise.all 天然 barrier）再进入下一 stage
+// 4) finalSynthesis：最后一轮 leader（synthesisMode=true）综合所有 stage 交付
+```
+
+要点：
+- **批内并行**：`Promise.all`（不是现在的 `for await` 串行）。
+- **批间串行**：`Promise.all` 即 barrier，自动等齐。
+- **依赖可见性**：进入 stage N 的席位时，把**前面所有 stage 已交付席位的摘要**拼进它的 `newMessage`（复用 §交付状态：网关 `_collect_delivery_status` / `GET last-ai-message?max_chars=N`，前端也可在 stage 边界拉一次摘要拼进 task）。这样 `(B C)` 能看到 `A` 的产出。
+- **抢占 / 干预 / 暂停**：每个 stage 边界检查 `isStale()`（epoch），与现有自由 / 链条模式一致。
+- **rollback**：special run 已统一 `multitask_strategy=rollback`，并行多席位各自不同 thread，互不冲突。
+
+### 3.2 是否每 stage 都走 leader？ — ✅ 已定：前端直派（方案 B）
+
+**本期采用方案 B**：DAG 由用户**显式**指定，不需要 leader 再"决定派给谁"。前端**直接**对 stage 内每个席位发起 special run，省掉每 stage 的 leader LLM 往返（更快、更可控）；只在所有 stage 完成后、`finalSynthesis` 为真时跑**一轮** leader（`synthesisMode=true`）综合所有交付。
+
+> （备选方案 A：每 stage 跑一轮 leader 派活——更贴现有架构但每 stage 多一次 leader LLM、更慢。**本期不采用**，留档备查。）
+
+### 3.3 后端改动
+
+- **基本不需要新接口**：special run（`POST /api/multi-agent/run/stream` agent_type=special）、leader run、轻量交付读（`GET /threads/{id}/last-ai-message`）、轻量追加（`POST /threads/{id}/messages/append`）都已就绪。
+- 仅需 §4 的「并行禁写文件」run policy 开关。
+
+### 3.4 验收（Phase 3）
+
+- `(B C)` 两席位**同时**出现在执行（后端日志两条 special run 时间重叠；前端两个流并行增长）。
+- stage 间严格串行（stage 2 不早于 stage 1 全部完成）。
+- stage N 席位的输入里能看到 stage <N 的交付摘要。
+
+---
+
+## 4. 并行时禁止写文件（防沙箱打架）
+
+### 4.1 后端 run policy
+
+`app/gateway/roundtable_run_policy.py` 现有角色：`leader` / `seat` / `report`。新增一个角色或开关：
+
+- 方案：给 `seat` 增加一个「并行变体」`seat_parallel`，其 `excluded_tools` 在 `seat` 基础上**再禁** `write_file` / `bash` / `str_replace` / `present_files`（与 `report` 角色禁写的思路一致）。
+- `_special_run`（`multi_agent.py`）按请求里的一个新 flag（如 `no_file: true`）选择 `seat_parallel` policy。
+
+### 4.2 前端传参
+
+- `streamMultiAgent` 请求体新增 `parallel_no_file?: boolean`（或复用 `no_file`）。
+- `runDagOrchestration` 在 `stage.agentIds.length > 1`（真并行）时置 `true`；单节点 stage（实际串行）不限制，可正常写文件。
+
+### 4.3 产物归属
+
+- 并行席位的产物 = **消息正文**（被 `_collect_delivery_status` / 综合块读取）。
+- 需要落文件 / 画图的（如 Step3 报告、`roundtable-report`）放在**串行的收口阶段**单独跑，不在并行批次里。
+
+### 4.4 验收（Phase 4）
+
+- 并行 stage 的席位 run 日志显示 `Excluded ... ['write_file','bash','str_replace','present_files', ...]`。
+- 并行期间不再出现多个席位抢同一沙箱 / 写文件冲突。
+
+---
+
+## 5. 并行执行的前端显示
+
+### 5.1 布局总览（并行进行时）
+
+```
+┌ 多智能体圆桌会商中心 ─────────────────────────────────────────────┐
+│ [头像条：进行中的并行智能体]            [模型选择 ▾] [暂停会商]     │
+│  (情报)●  (方案)●  (风险)●  (执行)  …                              │
+│   ↑选中    ↑选中    loading  hidden                                │
+│ ───────────────────────────────────────────────────────────────── │
+│  ┌─ 方案设计（选中）──────────┐  ┌─ 风险审查（选中）──────────┐   │
+│  │ 一、整体架构…（流式渲染）  │  │ 1. 合规风险 IDFA/OAID…     │   │
+│  │ …                          │  │ …                          │   │
+│  └────────────────────────────┘  └────────────────────────────┘   │
+└───────────────────────────────────────────────────────────────────┘
+（左侧"参与角色"栏在并行时整体收起，腾出横向空间放两列消息）
+```
+
+### 5.2 关键交互（与需求逐条对齐）
+
+1. **收起左侧**：并行执行时把左侧「参与角色 / 人工参与」栏整体折叠（一个 `isParallelRunning` 状态控制；非并行恢复）。
+2. **头像条**：位置在**消息列表上方、模型选择器左侧**。展示**当前并行批次的所有进行中智能体头像**：
+   - **进行中** → 头像加 loading 动画（复用 `DispatchChainModal` 的 `animate-ping` 光环 + `Loader2Icon animate-spin` 角标）。
+   - **已完成** → 打勾（复用现有 `CheckIcon` 角标）。
+   - **选中** → 高亮描边（当前正在主区显示的那 2 个）。
+3. **主区同时显示 2 个**：被选中的 2 个智能体的消息列表**并排两列**渲染。
+4. **多于 2 个先隐藏**：未选中的智能体**不渲染 DOM**（见 §6 性能）。
+5. **点头像切换**：点击未选中的头像 → 把它设为选中之一（替换当前 2 个里的一个，或按"最近点击保留 2 个"的 LRU 策略）；被换下的智能体**停止渲染但继续接流**。
+
+### 5.3 选中策略 — ✅ 固定 2 列，窄屏降 1 列
+
+- 维护 `selectedParallelSeats: string[]`，**最多 2**（固定 2 列）。**不做 3+ 列**。
+- **响应式**：宽屏 2 列并排；窄屏（建议断点 `< 1024px` / `lg`）降为**1 列**，头像条横向滚动切换；此时 `selectedParallelSeats` 仍可存 2 个，但主区只渲染当前 1 个（点头像切换哪个在前）。
+- 默认选中本批次**最先开始**的（宽屏 2 个 / 窄屏 1 个）。
+- 点头像：若已选中则取消；未选中则加入（超过上限时按 LRU 踢掉最早选中的）。被换下的席位**停止渲染但继续接流**（§6）。
+
+### 5.4 验收（Phase 5）
+
+- 并行时左侧收起、出现头像条、主区两列。
+- 进行中头像有 loading；完成打勾；选中有高亮。
+- 点头像能切换主区显示的智能体，且切换是**即时**的（数据已在内存，见 §6）。
+
+---
+
+## 6. 流式高性能策略（避免页面卡死）
+
+> 核心矛盾：N 个并行席位同时高频 `onTextDelta`，若都 setState + Markdown 渲染会卡死。
+
+### 6.1 全接收、惰性渲染
+
+- **所有**并行 run 的流都正常订阅（不丢数据）：每个席位的增量文本**累积进 store / ref**（`Map<agentId, { text, status, charCount }>`）。
+- **只有被选中（主区显示）的席位**才把累积文本挂到 DOM 渲染（Markdown）。
+- **未选中**席位：只更新内存 + 头像条上的轻量进度（字数 / loading），**不挂载消息 DOM**。
+- 切换选中时：把该席位已累积的全文一次性渲染 + 继续接增量。
+
+### 6.2 渲染节流
+
+- 选中席位的流式渲染**节流/合帧**：用 `requestAnimationFrame` 或 ~50–100ms 批量 flush 累积的 token，而不是每个 token 一次 setState。
+- Markdown 渲染对"流式中"可降级（纯文本 / 轻量渲染），**完成后**再做完整 Markdown（现有 `MessageBubble` 的 `streaming` 标志可复用：streaming 时简渲、done 后全渲）。
+
+### 6.3 头像条进度
+
+- 头像条只显示**廉价**信息：loading 动画 + 可选字数（`charCount`，从内存 Map 取，节流更新，例如每 500ms 刷一次）。不触发消息体渲染。
+
+### 6.4 数据流（建议结构）
+
+```
+streamMultiAgent(seat).onTextDelta(text) →
+    parallelStore.append(seatId, text)          // 纯内存累积，O(1)
+    if seatId ∈ selectedParallelSeats:          // 仅选中的进 React state（节流）
+        scheduleFlush(seatId)                    // rAF / 节流 setState
+    else:
+        bumpCharCount(seatId)                    // 仅更新头像条进度（节流）
+```
+
+### 6.5 验收（Phase 6）
+
+- 6+ 席位并行时页面不卡（输入 / 滚动 / 切换流畅）。
+- 切到一个之前隐藏的席位，能立刻看到它**到目前为止的全部**输出（证明流没丢、只是没渲染）。
+
+---
+
+## 7. 流程图执行态可视化（DAG 版）
+
+- 把现有 `DispatchChainModal.tsx`（横向**线性**流程图）扩展 / 复刻成 **DAG 流程图**：
+  - 按 stage 分**列**，stage 内席位**纵向并列**，stage 间用连接线。
+  - 节点状态复用 `ChainNodeState`（pending / active / done）+ 现有动画（`animate-ping` / `Loader2Icon` / `CheckIcon`）。
+  - 末尾接 `共识 → 结果绘制` 里程碑（沿用现有）。
+- 用途：编辑器里的只读预览（§2.2 底部）+ 执行时的总览（可选小窗 / 顶部缩略）。
+
+```
+总控 ─▶ ┌ Stage1 ┐ ─▶ ┌ Stage2 ┐ ─▶ ┌ Stage3 ┐ ─▶ 🤝共识 ─▶ 📊报告
+        │ 情报●  │     │ 方案✓  │     │ 执行○  │
+        └────────┘     │ 风险●  │     └────────┘
+                       └────────┘
+```
+
+### 7.1 验收（Phase 7）
+
+- 编辑器底部 / 执行时能看到 DAG 流程图，节点状态随执行实时更新（active/done）。
+
+### 7.2 实施结论（2026-06-07，✅ 已完成）
+
+- **新组件** `components/DagFlowChart.tsx`：纯展示组件，复刻 `DispatchChainModal` 的节点 / 连线 / 里程碑视觉（`animate-ping` 光环 + `Loader2Icon` 转圈 + `CheckIcon` 打勾 + `rt-chain-connector` 连线动画），但按 **stage 分列**：总控 ─▶ ┌Stage1┐ ─▶ ┌Stage2┐ ─▶ 🤝共识 ─▶ 📊结果绘制，stage 内席位**纵向并列**。`compact` 紧凑模式给缩略图用。所有状态由 props 传入（`stages` / `resolveSeat` / `seatStates` / `coordinatorState` / `consensusState` / `reportState`）；不传 `seatStates` → 全 pending（只读预览）。`aggregateStageState` 把 stage 内席位聚合成列状态(任一 active→active、全 done→done)驱动 stage 间连线。
+- **编辑器只读预览**（§2.2 底部）：`BusinessChainEditorPage` 底部加「编排预览」section，把 `stageGroups`(去空 stage) 映射成 `DagFlowChart` 的 stages + `resolvePreviewSeat`(席位名/配色)，`compact`、全 pending、随编辑实时变。
+- **执行态总览**（Step 2 顶部缩略）：`useStep2Orchestration` 新增 `dagNodeStates: Record<agentId, ChainNodeState>`，`runDagOrchestration` 跨 stage 维护(进入 stage→该批 active、席位终态→done、`resetStep2State` 清空)；经 `RoundtablePlanningPage` 把 `orchestrationMode/orchestrationPlan/dagNodeStates` 传到 `Step2Panel`，dag 模式下会话区顶部 `compact` 渲染 DagFlowChart。总控/共识里程碑状态由 `Step2Panel` 从节点状态 + `isOrchestrating`/`hasConsensus` 派生（中转轮时无席位 active + isOrchestrating → 总控 active）。
+- 改动文件：`components/DagFlowChart.tsx`(新)、`pages/BusinessChainEditorPage.tsx`、`hooks/useStep2Orchestration.ts`、`components/Step2Panel.tsx`、`pages/RoundtablePlanningPage.tsx`。typecheck 零新增(基线 65)。
+- **下次实地验收**：①编辑器底部随分层编辑实时画出流程图;②Step2 dag 模式顶部出现缩略流程图,跑起来后当前 stage 列点亮(active 转圈)、完成打勾、中转时总控亮、最后共识亮。
+
+---
+
+## 8. 分步实现计划（每步可独立交付 + 验收）
+
+| Phase | 内容 | 主要文件 | 依赖 | 可独立验收 |
+|---|---|---|---|---|
+| **1** | DAG 数据模型 + 校验 + 持久化字段 | `lib/dag-types.ts`（新）、draft step2 读写 | — | 纯函数单测：`validatePlan` / `chain→dag` 兼容转换 |
+| **2** | 分层编排编辑器（先无拖拽：点选加入/移出） | `components/DagPlanEditor.tsx`（新）、Step2 模式切换 | P1 | 能编排并保存/恢复，非法编排有提示 |
+| **2.5** | 编辑器拖拽 | 同上 + `@dnd-kit`（若引入） | P2 | 拖拽分配/重排 |
+| **3** | `runDagOrchestration`：批内并行 + 批间串行 + 依赖摘要注入 | `hooks/useStep2Orchestration.ts`、`api/multi-agent.ts` | P1 | 后端日志并行 special run 时间重叠；stage 严格串行 |
+| **4** | 并行禁写文件 run policy | `roundtable_run_policy.py`、`multi_agent.py`、`api/multi-agent.ts` | P3 | 并行 run 的 excluded_tools 含 write_file/bash/... |
+| **5** | 并行显示骨架：收起左侧 + 头像条 + 两列 + 选中切换 | `components/Step2Panel.tsx`、`components/ParallelSeatStrip.tsx`（新） | P3 | 见 §5.4 |
+| **6** | 流式高性能：全接收 / 惰性渲染 / 节流 | `hooks/useStep2Orchestration.ts`（parallelStore）、`Step2Panel` | P5 | 见 §6.5（6+ 并行不卡） |
+| **7** | DAG 流程图执行态可视化 | `components/DagFlowChart.tsx`（复刻自 `DispatchChainModal`） | P2、P3 | 见 §7.1 |
+| **8** | 边界 / 异常 | 各处 | 全部 | 见 §9 |
+
+> 落地顺序建议：**P1 → P3 → P4 → P5 → P6**（先把"能并行跑 + 能看 + 不卡"打通），**P2 编辑器**可与 P3 并行开发（先用一份 hardcode/简单 UI 的 plan 驱动 P3 联调），**P7 / P2.5 / 2.3** 作为增强后置。
+
+---
+
+## 9. 边界与异常（Phase 8）
+
+- **某并行节点失败 / 超时**：单个席位失败不拖垮整 stage；标该节点 error，stage 其余 ✅ 仍推进；收口时把"X 失败"如实告知总控（复用交付状态 ⬜ + 失败标记）。
+- **依赖未满足**：调度器保证 stage 串行，理论不会发生；防御性校验 stage N 启动前 stage <N 必须全部终态（done/failed）。
+- **人工干预 / 暂停 / 恢复**：在 stage 边界检查 `isStale()`（epoch）；干预指令插入后，从"下一个未开始的 stage"继续（已完成 stage 不重跑）。
+- **并行禁写文件 vs 席位本想写文件**：在席位 SOUL / 派活提示里说明"本轮为并行研讨，产出请直接写在回复正文，不要写文件"，降低模型困惑。
+- **窄屏**：主区两列降为一列 + 头像条横向滚动。
+- **单 stage 全并行（一次性 N 个）**：给并行度 warning（远程模型并发限流 / 成本）。
+
+---
+
+## 10. 与现有代码的衔接点速查
+
+- 编排循环：`hooks/useStep2Orchestration.ts`（`runOrchestration` / `runChainOrchestration` 旁新增 `runDagOrchestration`；复用 `isStale()` epoch、`abortAllInFlight`、`appendStreamingDialogue` / `appendToDialogue`）。
+- 流式 API：`api/multi-agent.ts`（`streamMultiAgent`，新增 `parallel_no_file` 入参；`onTextDelta(text, messageId)` 已是按席位回调，天然支持并行分流）。
+- 显示：`components/Step2Panel.tsx`（消息列表 `step2RoundtableDialogues.map`；新增头像条 `ParallelSeatStrip` + 两列容器 + 折叠左侧）。
+- 流程图：`components/DispatchChainModal.tsx` / `lib/job-types.ts` / `lib/business-chain.ts`（复刻成 DAG 版）。
+- 常量 / 元数据：`lib/roundtable-constants.ts`（`BUILTIN_AGENT_META` 头像/中文名、`buildAgentNameToRole`）。
+- 后端 run policy：`app/gateway/roundtable_run_policy.py`（新增 `seat_parallel`）、`app/gateway/routers/multi_agent.py`（`_special_run` 读 `no_file` flag）。
+- 交付摘要：`GET /api/threads/{id}/last-ai-message?max_chars=N`（依赖注入 stage N 输入用）。
+
+---
+
+## 11. 一句话总结
+
+把「线性链条」升级为「分层 DAG」：**编辑器**用分层 stage（拖卡片）表达串/并；**调度**用 `Promise.all` 批内并行、批间 barrier 串行，依赖摘要在 stage 边界注入；**并行禁写文件**避免沙箱打架；**显示**收起左侧、头像条切换、主区两列、未选中只接流不渲染（rAF 节流）保证不卡。全部建立在现有 special/leader run + 轻量交付接口之上，后端几乎零新接口。
+
+---
+
+## 12. 已知问题与排查记录（2026-06-06）
+
+### 12.1 ❗并行席位「步骤条」不显示 —— 根因：`seat_parallel` 工具面禁得过多
+
+**现象**：并行两列里的席位气泡看不到步骤条（`MessageStepsCard`），而串行席位有。
+
+**排查结论（已定位，待修）**：
+
+1. **步骤条只渲染「工具调用」步骤**。`MessageStepsCard` 的 `isToolStep` 只认 `tool_calling:<toolName>` 的步骤进折叠卡；纯阶段步骤（`connecting:` / `streaming:` 这类 reasoning）只渲染成**底部一行小灯泡**，不出大卡（见 `MessageStepsCard.tsx` L80-100）。
+2. **并行席位几乎调不动任何会产生步骤的工具**。后端 `app/gateway/roundtable_run_policy.py`：
+   - `_SEAT_EXCLUDED = [web_search, ask_clarification, present_files, view_image, agent_orchestration]` —— **注意 `web_search` 对所有席位（串行也）就禁了**（注释「圆桌研讨里联网搜索一律禁用」）。
+   - `_SEAT_PARALLEL_EXCLUDED = _SEAT_EXCLUDED + [write_file, bash, str_replace]`。
+   - 于是并行席位可用工具几乎只剩 `read_file / ls / task / write_todos / memory / hindsight_*`，研究/分析类席位基本一个都不会调 → **没有任何 `tool_calling` 步骤** → 步骤条（大卡）不出现。
+3. **对比串行为何「有步骤条」**：串行席位（`seat` policy）**能 `write_file`**，会产生 `tool_calling:write_file` 步骤 → 大卡出现。并行被禁了 write_file + 又没有 search，所以一个工具步都没有。
+
+**用户诉求**：并行时**只禁真正会冲突的写操作**，搜索信息 / 调用技能等**必要操作不要禁**。
+
+**关键事实（影响方案选择）**：圆桌每个席位是**独立 thread = 独立 sandbox**（后端 per-thread 隔离 `.deer-flow/users/{uid}/threads/{tid}/`）。所以并行席位写文件**在后端并不会互相冲突**；当初 §4「并行禁写文件」的「打架」其实主要是**前端单沙箱预览**（`activeArtifactThreadId` 只能同时显示一个）+ 产物归集到正文的简化考量，并非后端真冲突。→ 这意味着「并行禁写」的必要性比原设想弱，可放宽。
+
+**✅ 决策：选 A（2026-06-06 已实施）**：把 `seat_parallel` 放宽到**只禁 `write_file / bash / str_replace`**（防前端单沙箱预览串台 + 产物走正文）+ 仍禁 `ask_clarification / present_files / view_image / agent_orchestration`（打断/越权类），但**放开 `web_search` 与技能**（搜索不碰 sandbox；技能靠 `read_file`）。改在 `app/gateway/roundtable_run_policy.py` 的 `_SEAT_PARALLEL_EXCLUDED`（**不再继承** seat 的 web_search 禁用，显式列举），测试 `tests/test_roundtable_run_policy.py` 同步更新（`test_seat_parallel_allows_web_search_and_skills`）。
+→ 并行席位现在能联网搜索/用技能 → 产生 `tool_calling` 步骤 → 步骤条显示。
+
+> 备选 B（连写文件也放开，沙箱按 thread 隔离）/ C（重新评估「圆桌串行也一律禁 web_search」）**本期不做**，留档。串行席位目前仍禁搜索（`seat` policy 不变）。
+
+### 12.2 其它已修（本轮反馈）
+
+- 最左侧**全局工作区侧栏**并行时收起：改用与「打开沙箱」同一路径 `useSidebarSafe()?.setOpen(false)`（之前只收了圆桌「参与角色」栏 `step2SidebarExpanded`）。并行结束**不自动展开**（与沙箱收起不回弹一致）。
+- 并行两列改回**完整 Markdown**（撤销 §6.2 流式纯文本降级 `plainWhileStreaming`），与串行同款 `Step2Message`。
+- 头像条**不再显示字数**（去掉 charCount 徽标 + 字段）。
+- **致命 bug 已修**：用户干预 / 并行跑完后**不再重跑整张 DAG**。`dagPlanExecutedRef` 闸门 + DAG 各阶段跑完后释放锁 `await runOrchestration(handoff)` 交回总控继续派活/收口；后续干预/恢复一律走 leader 自由派活。
+- **并行两列宽表溢出已修（2026-06-07）**：模型输出的 Markdown **表格**（如「法律免责条款」表）没有宽度约束 / 横向滚动容器，在并行两列的窄列里会**超出左列、盖到相邻列**。修法：`MessageBubble.sharedMarkdownComponents.table`（+ `markdown-components.tsx`）把 `<table>` 套进 `<div class="max-w-full overflow-x-auto">`——表格保持自然宽度、超出时**列内横向滚动**而非撑破列宽。`min-w-0` 链(grid `minmax(0,1fr)` → 列 `min-w-0` → 气泡 `flex-1 min-w-0`)本就齐全,只差 table 这一层。
+- **关于「并行席位无步骤条」**：步骤条(`MessageStepsCard` 大卡)只在席位产生 `tool_calling` 步骤时出现(§12.1)。纯分析型席位若本轮**直接写分析正文、没调用任何工具**(web_search 等),就只显示一行「正在输出」思考指示、不出大卡——这是设计使然,非解析失败。要确认是否真调了工具:浏览器 devtools 设 `window.__MULTI_AGENT_DEBUG__=true` 看 `frame# event=messages` 里有无 tool_calls,或查后端 special run 日志。
+
+### 12.3 ✅需求变更：Stage 间「经总控中转 + 广播」（2026-06-06 提出，2026-06-07 已实施）
+
+**当前实现（方案 B，§3.2）**：DAG 各 stage 由前端**直接**派活，stage 间不跑 leader，靠前端把 `buildDependencySummary` 拼进下一 stage 的 task（`priorSummary`）。各 stage 跑完后才 `await runOrchestration` 交回总控收口。
+
+**新诉求**：业务链条调用时，**每一轮 stage 之间都要经总控中转 + 广播**，而不是前端直接串下去。具体：
+
+1. 第 1 轮并行调用 stage1 的 A、B、C；
+2. A/B/C **全部完成后**，把这一批的**输出广播出来**（广播给其它席位 + 总控 thread）；
+3. **总控（leader）接收**这批交付 → 再**往下继续派活**（派 stage2 的 D、E）；
+4. 派活时把（承上的）消息**广播给下一轮的 D、E**；
+5. 以此类推，直到所有 stage 跑完再收口。
+
+> 即把 §3.2 的「方案 B 前端直派」改成 **「方案 A' = 计划约束下的总控中转」**：stage 边界插入一轮 leader，由它综合上一批交付并驱动下一批（下一批席位仍由编排计划**钉死**为 D、E，不是 leader 自由乱派——leader 负责「承上启下 + 广播上下文」，计划负责「派给谁」）。
+
+**实施要点（下次会话）**：
+
+- **每个 stage 完成 → 广播该批输出**：后端 `_special_run` 已对每个 seat 做 detached 后广播（「子智能体X完成…交付内容为:…」→ 其它席位 + 总控）。但它是 **detached/best-effort + 截断**；要让总控**可靠**地在下一轮前看到，需在 stage barrier 处**等广播落地**（或前端在 stage 边界用 `GET /threads/{id}/last-ai-message` 主动收齐各席位交付再喂给 leader）。
+- **插入 leader 中转轮**：`runDagOrchestration` 在进入下一 stage 前，跑一轮 leader（`synthesisMode=true` 让后端注入上一批**完整**交付），让总控产出一段「承上启下」说明；把这段说明（而非机械 `priorSummary`）作为下一 stage 席位 task 的上下文 / 或广播给下一批席位 thread（复用 `POST /threads/{id}/messages/append`）。
+- **下一批仍由计划钉死**：leader 中转轮**不**自由决定派给谁（计划已定 D、E）；可参考 `buildChainLeaderTask` 的「约束 leader 只派给指定席位」思路，或干脆 leader 只做综合、前端照计划派 D、E 并把 leader 综合 + 广播注入其 task。
+- **与「并行禁写」「§12.1 放开搜索」并存**：中转/广播不影响工具面。
+- **与致命 bug 修复并存**：最后一个 stage 跑完仍走「交回总控（`runOrchestration`）收口/继续派活」；用户干预仍走 leader、不重跑 DAG。
+
+**影响文件（预估）**：`hooks/useStep2Orchestration.ts`（`runDagOrchestration` 的 stage 循环里加 leader 中转 + 广播收齐）、可能复用后端 `_leader_run`（synthesisMode 注入全文）/ `/messages/append`（广播）/ `/last-ai-message`（收齐交付）。后端基本无需新接口。
+
+**✅ 实施结论（2026-06-07）**：后端**零改动**，全部在前端 `runDagOrchestration` 内完成，复用既有「传摘要按需传全文」优化链路：
+
+1. **中转轮位置**：每个**非最后**的 stage barrier 到达后（`Promise.all` 收齐本批交付），插入**一轮 leader**「中转轮」，展示为「总控协调（承上启下）」气泡。最后一个 stage 后**不**插中转，综合/收口仍交给末尾的 `runOrchestration` 接管（与致命 bug 修复一致）。
+2. **可靠收齐交付（传摘要）**：中转轮跑 `streamMultiAgent({agentType:"leader", synthesisMode:false})`。后端 `_leader_run` 本就在每轮 leader 前用 `_collect_delivery_status`（走**轻量 `GET /last-ai-message?max_chars=600` 接口**）**客观核对**各席位真实交付并把**摘要**注入总控输入（`_build_seat_status_block`）——比 detached 广播可靠（直接实读各席位 thread，不依赖 best-effort 广播是否落地）。故中转轮传 `synthesisMode:false`：只综合本批、**不收口**，只注入摘要；**完整交付正文**留到末尾收口的 synthesis 轮（`_build_full_deliverables_block`，全 ✅ 才注入）按需读取——即「**传摘要按需传全文**」。
+3. **承上启下驱动下一批**：中转轮产出的综合说明存进 `leaderBridge`，作为**下一 stage** 席位 task 的上下文（`buildStageTask({priorSummary: leaderBridge, priorIsBridge:true})`，措辞为「承上启下综合说明」而非机械「交付摘要」），替代原来的 `buildDependencySummary(deliveries)`。中转失败/无产出时回退机械依赖摘要，不阻断。
+4. **下一批由计划钉死**：中转轮提示（`buildDagTransitTask`）明确告知总控「下一阶段席位已由编排计划钉死为 X、Y，你**不要**自行 `agent_orchestration` 派活、**不要**收口」，前端仍照计划直派下一批；即便弱模型仍派了活，前端忽略其 `dispatched`、只取 `content` 当 bridge。
+5. **广播**：本批输出广播给其它席位 + 总控 = 后端 `_special_run` 既有 detached 后广播（截断摘要）；承上消息给下一批 = 注入其 task `new_message`（席位 run 输入必见，比 `/messages/append` 更可靠，省一次写盘）。
+6. **澄清/抢占/失败**：中转轮触发澄清 → 暂停 DAG（回复后走 leader 自由派活、不重跑 DAG，沿用 `dagPlanExecutedRef` 闸门）；被 `isStale()`/abort 抢占 → 静默收尾；异常 → 该气泡标错误、清空 bridge 继续。
+
+**纯函数**：`lib/dag-types.ts` 新增 `buildDagTransitTask`（中转轮提示）+ `buildStageTask` 加 `priorIsBridge` 形参；`lib/dag-types.test.ts` 加 4 个单测（共 27 个全过）。
+
+> ⚠️ **§12.3 的「单独中转轮 + 前端直派」已被 §12.4 取代**（2026-06-07 同日）：见下。`buildDagTransitTask` / `buildStageTask` / `buildDependencySummary` 仍保留在 lib（带单测），但 `runDagOrchestration` 不再调用它们。
+
+### 12.4 ✅ 需求再变更：DAG 改成「总控驱动每 stage 派活」（2026-06-07，§3.2 方案 A）
+
+**新诉求（用户原话）**：把并行(DAG)逻辑改得和串行一样——串行时总控给多个智能体派活、它们完成后汇报给总控、总控再继续往下派活；并行也改成「由总控判断要执行哪些步骤，这些步骤完成后再汇报给总控，总控继续往下派活」。
+
+**已确认的两个关键决策**：
+1. **每批「派给谁」**：✅ **计划钉死成员，但走总控派活**（不是总控自由乱派）。即 stage 成员仍由编排计划定死，但改成总控每轮**真正** `agent_orchestration` 派活给这些席位（约束只派给它们、且每个都派到）。= §3.2「方案 A」+ 批内并行。
+2. **适用范围**：✅ **只改 dag 模式**（recommend 仍串行逐个、chain 不动）。
+
+**实现（后端零改动，全在 `runDagOrchestration`）**：每个 stage 两步——
+- **(a) 总控派活轮**：跑一轮 `leader`，提示 `buildDagStageLeaderTask`（首 stage 带任务背景；后续 stage 靠后端注入的此前交付摘要承上；列出本 stage 钉死席位的 `agent_name`，要求逐个派到、不派清单外、不收口）。`synthesisMode:false` → 后端 `_build_seat_status_block` 走轻量 `last-ai-message` 注入各席位**摘要**（传摘要按需传全文）。
+- **(b) 批内并行**：本 stage 席位并行跑总控派给各自的 task——`pickDagSeatTask(leaderRes.dispatched, content, agentId, name)` 命中其 `agent_name`；总控漏派/写偏则回退总控正文/模板，**不借用别席位 task**（多席位并行避免张冠李戴）。完成后交付经后端 `_special_run` detached 后广播回总控；下一 stage 的派活轮即可看到。
+- barrier 后进入下一 stage，总控再派下一批。全部 stage 跑完 → 交回 `runOrchestration` 收口（synthesisMode 按需注入全文）。
+
+**相比 §12.3 的变化**：§12.3 是「前端直派 + stage 间单独插一轮只综合的中转轮」；§12.4 把**每个 stage 本身**就改成「总控派活轮 + 批内并行」——总控既承上（注入的摘要）又派活，不再需要单独的中转轮。与 chain 模式同构，区别是一次钉死一批、批内并行。
+
+**纯函数**：`lib/dag-types.ts` 新增 `buildDagStageLeaderTask`（每 stage 派活提示）+ `pickDagSeatTask`（取某席位 task，多席位不张冠李戴）；`lib/dag-types.test.ts` 加 5 个单测（共 32 个全过）。`runDagOrchestration` 不再用 `buildStageTask/buildDependencySummary/buildDagTransitTask`（保留在 lib）。
+
+**Phase 7 流程图兼容**：总控派活轮无席位 active + `isOrchestrating` → 流程图「总控」节点显示 active（承上派活中），随后该 stage 列点亮，无缝衔接。
+
+**下次实地验收**：①每个 stage 前出现「总控协调（派活中/承上派活中）」气泡,内容是总控对本 stage 席位的派活说明;②后端日志该轮 leader 的 `_partition_dispatch` 派给的正是本 stage 钉死席位;③这些席位并行跑(special 日志时间重叠);④完成后下一 stage 总控派活轮能看到上一批交付摘要(`[leader-roster]` 日志)。
+
+### 12.5 ✅ 流程图弹窗化 + DAG「快速/沙箱」执行子模式（2026-06-07）
+
+三个改动一起做:
+
+**(1) 流程图改成弹窗**:Step2 顶部不再内联 `DagFlowChart`(挤占两列消息高度,截图 `样式优化-1.png`)。改成一条细栏「分层编排执行中 · 共 N 个阶段 ＋ [查看编排流程图]」按钮,点开 `Dialog` 看**全尺寸**流程图(非 compact)。编辑器(`BusinessChainEditorPage`)底部预览保持内联不变。改 `Step2Panel.tsx`(加 `dagFlowOpen` state + Dialog)。
+
+**(2) 推荐弹窗新增 DAG 执行子模式(快速/沙箱)**:`BusinessChainPicker` 在选中链条**有分层并行**(走 dag)时,「进入研讨」旁出现「执行方式:快速·双列禁写 / 沙箱·单列可写」二选一(只 dag 时出现,§已确认)。
+   - **快速(`fast`,默认)**:同 stage 席位**并行**、主区**双列**、`parallelNoFile=true`(seat_parallel **禁写文件**)。= 之前的行为。
+   - **沙箱(`sandbox`)**:同 stage 席位**仍并行**,但主区**单列**(`selectedParallelSeats` 最多 1)、`parallelNoFile=false`(seat policy **允许写文件**);点头像切换查看,沙箱跟随当前席位。
+   - 数据流:`SeatSelectionResult.dagExecMode` → `RoundtablePlanningPage` state(持久化进 `DraftStep2(Run)Snapshot.dagExecMode`,mirror orchestrationPlan)→ `useStep2Orchestration` option → `runDagOrchestration`。
+
+**(3) 沙箱跟随当前显示席位(防 bug 重点,用户特别强调)**:`useStep2Orchestration`
+   - `sandboxFollowThreadIdRef` = 当前显示席位的 thread;`openSeatVirtualArtifact` 的 auto 守卫:sandbox 模式下,**后台并行席位**写文件时若不是当前显示席位,**不自动打开**(否则沙箱内容和主区列表错位)。
+   - 切换显示席位的 effect(keyed on `selectedParallelSeats` + `dagExecMode`):该席位**有产物**(stub 里有 write_file/str_replace)→ `openSeatLatestArtifact` 强制打开它最新的文件;**无产物**→ 关闭沙箱面板(`setActiveArtifactThreadId(null)` + `deselectArtifact` + `setArtifactsOpen(false)`)。
+   - 当前显示席位 live 写文件 → `handleArtifactToolPhase` auto-open,守卫放行(follow===该席位)。后台席位写 → 守卫拦掉、只缓存 stub;切到它时 effect 再打开。
+   - `toggleParallelSeat`:sandbox 单列 = 点头像切换(始终保留 1 个,不取消到空);fast 双列 = 原 LRU 2 个。
+
+**改动文件**:`lib/business-chain.ts`(SeatSelectionResult.dagExecMode)、`components/BusinessChainPicker.tsx`(子模式 UI)、`api/drafts.ts`(快照 dagExecMode)、`pages/RoundtablePlanningPage.tsx`(state/snapshot/hydrate/confirm/reset 全链)、`hooks/useStep2Orchestration.ts`(option + parallelNoFile/单列 + 沙箱跟随 + toggle cap)、`components/Step2Panel.tsx`(流程图弹窗 + 单列 grid)。typecheck 零新增(基线 65),dag-types 32 单测全过。
+
+**下次实地验收(沙箱跟随是重点)**:①推荐弹窗选有并行的链条 → 出现「快速/沙箱」二选一;②快速=双列禁写(无沙箱);③沙箱=单列、席位能写文件、点头像切换列表时沙箱内容**同步**切换:有产物显示、无产物关闭;④后台席位写文件不会把沙箱抢到非当前列表;⑤流程图点按钮弹窗、全尺寸、节点随执行点亮。
+
+### 12.6 ✅ 修:并行席位「跟着派活」（2026-06-07）
+
+**现象**(截图 `bug-1.png`):总控派活后,并行席位的气泡里显示的是**总控的整段派活叙述**(「我来调度各智能体…第1阶段任务清单:席位1…席位2…」),还去调 `skill_list` 找 `agent_orchestration`——席位在**模仿派活**。
+
+**根因**:总控这轮**没真正调用 `agent_orchestration` 工具**(弱模型 deepseek 用文字罗列了派活计划)→ 后端解析的 `dispatched=[]` → 前端 `pickDagSeatTask` 回退把**总控整段叙述**喂给**每个**席位 → 席位照抄叙述、模仿派活。(席位本就被 run policy 禁了 `agent_orchestration`,**派不了活**,只是空转一轮叙述 + 调 `skill_list`。)
+
+**修 v1(护栏,效果不足)**:`pickDagSeatTask` 加角色边界护栏 + 回退措辞改「挑出属于你的那份」;`buildDagStageLeaderTask` 加「必须真正调用工具」。→ **没拦住**:总控对 deepseek 仍只写文字不调工具(`dispatched` 还是空),席位拿到的**任务正文本身**就是那段「我来调度…席位1/2/3」,护栏被淹没;3/4 席位仍模仿派活,有的甚至绕道 `bash`+`python requests.get('/api/agents')` 调内部接口派活(bug-1~4)。
+
+**✅ 修 v2(根治:回退绝不注入派活叙述)**:`pickDagSeatTask` 去掉 `leaderContent` 入参——
+- **命中**总控结构化派活(真调了工具)→ `请你作为「X」，完成总控派给你的本阶段任务：<dispatched task>` + 护栏;
+- **未命中 / `dispatched` 空**(总控只写文字)→ **绝不**把总控派活叙述喂给席位,改给**干净本职任务**:「请你作为「X」,从你的专业职责出发,独立完成本阶段属于你的分析与交付。任务背景与此前各阶段交付已在你的会话上下文里(后端广播注入),据此承接」+ 护栏。护栏强化到「不要用 bash/python/脚本访问内部接口(/api/agents、agent_orchestration)派活、不要复述『我来调度』总控口吻」。
+- `buildDagStageLeaderTask` 的「必须真正调用工具」保留(让命中率更高、尽量走 exact-match)。
+- `dag-types.test.ts` 改 2 单测(共 33 过)。typecheck 65。
+
+> ⚠️ **残留次要污染源(若仍复发再处理)**:DAG 每个 stage 的 leader 轮,后端 `_leader_run` 会把 leader 的输入(含「请你作为总控…派活」)**预广播**进所有席位线程(`总控智能体收到用户消息:…`)。席位的**当轮任务**已干净(修 v2),这条只是历史上下文,理论上被「最新的干净任务 + 护栏」压制。若实测仍模仿派活,下一步:后端给 DAG leader 轮加 `suppress_pre_broadcast` / 或广播一条**净化**过的背景(去掉派活措辞)。
+
+### 12.7 ✅ 修 4 项(2026-06-07):席位仍派活(v3 后端)+ 沙箱关不掉 + 并行不自动下滑 + 流程图只到 Step2
+
+实测 §12.6 仍有席位派活(视觉设计师 `skill_manage` 找 agent-orchestration、列 dispatch all 4)——**坐实**了「残留次要污染源」:后端 leader 预广播把派活 prompt 推进席位线程,弱模型从历史里捡到派活意图。一起修了 4 项:
+
+1. **席位仍派活(根治·后端)**:`_leader_run` 加 `suppress_pre_broadcast` 参数;DAG「每 stage 派活轮」前端传 `suppressPreBroadcast: true`(`api/multi-agent.ts` → `suppress_pre_broadcast`,run/stream 读取)。为真时:**不**把总控派活 prompt 预广播给席位、**也不**把「总控给 X 派活」detached 广播给兄弟席位。recommend/chain 不传该 flag,行为不变。配套:`pickDagSeatTask` 加 `seedMessage` 入参——预广播抑制后席位线程没有用户原始消息了,把**任务背景**直接写进席位 task(此前各阶段交付仍由 special 完成后广播注入)。→ 席位线程里**任何地方都没有派活语句**,根治模仿。
+2. **沙箱关闭按钮关不掉**:沙箱跟随 effect 之前每次 render(deps 身份变)都重跑 → 把用户刚关的沙箱强制重开。加 `lastReconciledSeatRef` 守卫:**只在显示席位真正变化时**才开/关沙箱;用户手动关闭(席位没变)时 effect 早退,不再回弹。
+3. **并行时自动下滑失效**:平铺列表 ↔ 网格(两列/单列)切换时 `scrollHeight` 突变、`scrollTop` 被浏览器 clamp → `useAutoScroll` 误判「用户上滚」而停跟随。`Step2Panel` 加 effect:`isParallelRunning` / `selectedParallelSeats` 变化时 `scrollStep2ToBottom()` 重新拉到底 + 恢复跟随。
+4. **流程图只展示 Step2**:`DagFlowChart` 加 `showReportMilestone`(默认 true);Step2 弹窗 + 编辑器预览传 `false` —— 只到「共识」(Step2 终点),去掉「结果绘制」(那是 Step3)。
+
+**改动**:后端 `multi_agent.py`(`_leader_run` suppress 两处广播 + run/stream 读 flag);前端 `api/multi-agent.ts`、`lib/dag-types.ts`(pickDagSeatTask + seedMessage)、`hooks/useStep2Orchestration.ts`(传 flag + seed + 沙箱跟随守卫)、`components/Step2Panel.tsx`(自动下滑 effect + showReportMilestone)、`components/DagFlowChart.tsx`、`pages/BusinessChainEditorPage.tsx`。`dag-types.test.ts` 共 **34 单测过**;前端 tsc 65 基线零新增;后端 `py_compile` OK。
+
+### 12.8 ✅ 席位产出 md 文件 + 禁写 .py（2026-06-07）
+
+**现象**:某次 7 席位**全都没产出 md 文件**;且一直有的问题——席位**有时写 .py 脚本**(用户要求:不写 .py,其它格式可以)。
+
+**根因(没 md)**:两层都堵了——(a)**快速模式** `seat_parallel` policy 禁了 `write_file`(原「产物走正文」设计);(b)DAG 席位**提示词**写的是「直接输出你的交付正文」,即使沙箱模式(允许写)也不会去写文件。
+
+**修**:
+1. **后端 policy 放开写文件、统一禁 bash**(`roundtable_run_policy.py`):
+   - `seat_parallel`:去掉 `write_file` / `str_replace` 禁用(**可写 md**),保留禁 `bash` + 打断/越权类;仍放开 `web_search`。
+   - `seat`:新增禁 `bash`(原来允许)——圆桌席位是「文档产出者」,不该跑 shell/python 脚本(弱模型爱写 .py 再跑生成产物,乱且抓不到预览);改为**直接 write_file 写成品文档**。
+   - `report`:`bash` 已随 `seat` 禁,改为 `[*_SEAT_EXCLUDED, "str_replace"]`(集合不变)。
+   - 测试 `test_roundtable_run_policy.py`:`test_seats_can_write_files_but_not_run_bash`(seat / seat_parallel 都可写文件、都禁 bash),6 用例过。
+2. **前端提示词**(`pickDagSeatTask`)加「产物要求」:**把完整交付写成一个 .md 文件**(write_file 到 outputs)+ 正文给摘要;**禁写 .py 或任何脚本文件**,.md/.html/.txt 等其它格式都可以,唯独不要 .py。
+3. **快速模式(双列)不自动开沙箱**(`openSeatVirtualArtifact` 新增守卫):放开写文件后,双列里多席位并发写文件会让单沙箱预览反复串台——fast 模式 DAG 并行批次**完全不自动开沙箱**(文件仍写盘,Step3/文件卡可查看);沙箱模式(单列)仍按「沙箱跟随当前席位」预览。
+
+**关于 .py 的强度**:`write_file` 是全局工具(所有 agent 共用),无法在网关层按扩展名硬拦,故 .py 禁止走**提示词**(强约束)+ **禁 bash**(写了也跑不了,脚本生成产物的动机被掐断)。若实测仍偶发写 .py 且需**硬拦**,下一步:给 lead_agent 的 `write_file` 工具加一个「按 run context 禁某些扩展名」的开关,网关 `_run_payload` 对圆桌席位置 `[".py"]`(只影响圆桌 run,不动其它 agent)。
+
+**改动**:`roundtable_run_policy.py`、`test_roundtable_run_policy.py`、`lib/dag-types.ts`、`lib/dag-types.test.ts`(35 过)、`hooks/useStep2Orchestration.ts`。前端 tsc 65、后端 py_compile OK + 6 policy 单测过。⚠️ **改了后端,需重启 Gateway**。
+
+### 12.9 ✅ 席位「按需取前序全文」只读工具 read_peer_delivery（2026-06-07）
+
+**诉求**:A,B,C → D,E 时,D,E 默认拿 A,B,C 的**摘要**,但识别到需要**全文**时也能取到。之前只有总控(leader)能「摘要默认+按需全文」(跨 thread 读),下游席位**不能**(席位间 thread 隔离、只有 1500 字截断广播)。
+
+**实现**(真·按需,全文只在调用工具时才进 LLM 上下文):
+1. **新 harness 只读工具** `read_peer_delivery(seat_name)`(`packages/harness/deerflow/tools/builtins/roundtable_peers_tool.py`):从 `runtime.context["roundtable_peer_deliveries"]`(网关注入的 `[{name,content}]`)按席位名取全文;空名→列出可取席位;非圆桌场景→「无」。只读 context dict,**不跨 thread、不碰 sandbox、无网络**,纯 `deerflow.*`(不违反 harness→app 防火墙)。注册进 `tools/tools.py` 的 builtin(始终在,只读无副作用)。
+2. **网关注入 context**:`_run_payload` 加 `extra_context`;`_special_run` 收 `peer_deliveries` → 注入 `context.roundtable_peer_deliveries`;run/stream 读 `peer_deliveries`(规整 `[{name,content}]`)。**不进 prompt → 不调工具就不耗 token**。
+3. **run policy**:`read_peer_delivery` 从 `leader`(总控自己跨 thread 读,不需要)+ `report`(Step3 不读前序)排除;**席位(seat/seat_parallel)保留**。
+4. **前端**:`runDagOrchestration` 跨 stage 累积**完整交付** `priorDeliveries`,stage>0 席位的 special run 带 `peerDeliveries`(`api/multi-agent.ts` → `peer_deliveries`);`pickDagSeatTask` 加 `hasPeers` 形参,有前序时在 task 里提示「需要某前序席位全文时调用 read_peer_delivery('<名>'),平时用摘要」。
+
+**最终语义**:D、E 默认看 A、B、C 的**摘要**(1500 字广播);识别到不够 → 调 `read_peer_delivery('情报收集')` 取**全文**。总控仍是摘要默认+综合轮全文。**= 用户要的「摘要默认、按需全文」对席位也成立了。**
+
+**改动**:后端 `roundtable_peers_tool.py`(新)、`tools/tools.py`、`roundtable_run_policy.py`、`multi_agent.py`;前端 `api/multi-agent.ts`、`lib/dag-types.ts`、`lib/dag-types.test.ts`(36 过)、`hooks/useStep2Orchestration.ts`。前端 tsc 65;后端 py_compile OK + 6 policy 单测过 + 工具导入/行为 smoke 通过。⚠️ **改了后端 + 新增 harness 工具,需重启 Gateway**。
+
+### 12.10 ✅ 修:沙箱模式第一个席位不自动开沙箱（2026-06-07，前端）
+
+**现象**:沙箱(单列)模式并行时,**第一个**席位的消息列表不自动打开沙箱(要手动开);切换到其它席位时正常自动打开。
+
+**根因**:沙箱跟随 effect(§12.5)在选中席位**还没写产物**时走「关闭沙箱」分支,里面同时调了 `deselectArtifact()` **和** `setArtifactsOpen(false)`。后者是 context 的 **wrapped setOpen**(`context.tsx:73`):`关闭时若 autoOpen 为真 → 把 autoOpen 置 false`。于是第一个席位刚选中(还没写文件)→ autoOpen 被关 → 该席位**随后 live 写文件**时,`openSeatVirtualArtifact` 的 `!flags.autoOpen` 守卫拦掉自动打开。切换到**已写过**文件的席位能开,是因为那条路走 `openSeatLatestArtifact`(force,auto=false,绕过 autoOpen 守卫)。
+
+**修**(一行):关闭分支只保留 `deselectArtifact()`(它走 raw `setOpen(false)`,**不**动 autoOpen),删掉多余的 `setArtifactsOpen(false)`。这样面板关掉、但 autoOpen 仍为真 → 第一个席位 live 写文件时正常自动开沙箱。(若用户**手动**关过沙箱,autoOpen 本就为 false,不会自动重开 —— 尊重用户。)改 `hooks/useStep2Orchestration.ts` 沙箱跟随 effect。tsc 65。
+
+### 12.11 ✅ 修:快速模式又生成文件了 + Fragment 警告（2026-06-07）；记录无关 404
+
+1. **快速模式不应生成文件(回退 §12.8 的过度放开)**:§12.8 为「让席位产 md」把 `seat_parallel`(快速模式)也放开了 write_file —— 但**快速模式(双列)的设计就是产物走正文、不写文件**,写文件归**沙箱模式**(单列 + 沙箱预览)。修:
+   - `roundtable_run_policy.py`:`seat_parallel` 重新**禁 write_file / str_replace**(保留禁 bash);`seat`(沙箱模式)仍可写。
+   - `useStep2Orchestration.ts`:`parallelNoFile = dagExecMode !== "sandbox"`(快速模式一律禁写,含单节点 stage;沙箱模式放开)。
+   - `pickDagSeatTask` 加 `allowFiles` 形参:沙箱(true)=写 .md 文件 + 禁 .py;快速(false)=产物走正文、不写文件。hook 按 `dagExecMode === "sandbox"` 传。
+   - 测试:`test_sandbox_seat_writes_files_fast_parallel_does_not`(6 过);`dag-types.test.ts` 拆成沙箱/快速两个产物要求用例(37 过)。
+   - **语义**:快速=双列、产物走正文、不写文件;沙箱=单列、写 .md、沙箱跟随预览。
+2. **`Invalid prop data-lov-id supplied to React.Fragment`**:`DagFlowChart` 的 stage 循环用了具名 `<Fragment key>`,dev 代码标注插件(lovable-tagger)给它注入 `data-lov-id`,而 Fragment 只接受 key/children → React 警告。修:换成 `<div className="contents" key=...>`(display:contents 不生成盒子,Connector/StageColumn 仍是外层 flex 直接子项,布局不变,且能接收 data-*)。移除 `Fragment` import。
+3. **(无关,非本期引入)`/api/getTokenByEmail?email=…%40local.deerflow` 404 ×60**:来自 `src/core/studio/api.ts` 的 `fetchStudioToken`(studio/expert-auth 引导),用户邮箱被映射到 legacy `@local.deerflow` 域、后端 `getTokenByEmail` 不认 → 404,React Query 跨多个 `useStudioToken` 调用点重试 → 重复多次。**与圆桌 DAG 改动无关**(圆桌头像是本地 SVG,本期未新增任何前端 GET)。需要的话单独排查 studio token 链路。
+
+---
+
+## 13. 实施进度（截至 2026-06-06，下次会话续）
+
+| Phase | 内容 | 状态 |
+|---|---|---|
+| 1 | DAG 数据模型 + 校验 + 持久化字段（`lib/dag-types.ts`，24 单测） | ✅ 完成 |
+| 2 | 分层编辑器（**做进业务链条页**）：链条加 `stages` 字段（前后端 + alembic `20260607_03` + 11 后端单测）；`BusinessChainEditorPage` 竖列分组 Stage（DnD + 按钮）；纯逻辑 `lib/chain-stages.ts`（19 单测） | ✅ 完成 |
+| 3 | `runDagOrchestration`：批内 `Promise.all` 并行 + 批间 barrier 串行 + 依赖摘要注入（方案 B 前端直派） | ✅ 完成 |
+| 4 | 并行 run policy `seat_parallel`（`roundtable_run_policy.py` + `multi_agent.py` 读 `parallel_no_file`，6 后端单测）；**§12.1 方案 A 已放开 web_search/技能** | ✅ 完成 |
+| 5 | 并行显示：收起左侧 + 头像条 + 两列 + 选中切换 | ✅ 完成（本轮修了侧栏/Markdown/字数） |
+| 6 | 流式高性能：ref 全量累积 + 节流 flush（仅选中渲染） | ✅ 完成 |
+| 7 | DAG 流程图执行态可视化（`DispatchChainModal` 复刻成按 stage 分列；后改成**弹窗**见 §12.5） | ✅ 完成（2026-06-07） |
+
+**端到端闭环已通**：链条页编排分层 → 存库 → 选链条进 Step2 → `runDagOrchestration` 并行直派 → 各阶段完交回总控派活/收口。
+
+**✅ §12.3 已实施（2026-06-07）**：见 §12.3「实施结论」。`runDagOrchestration` 在每个非末尾 stage barrier 后插入 leader 中转轮（`synthesisMode:false` 走轻量 `last-ai-message` 注入摘要、收口轮才按需全文），承上启下驱动下一批；后端零改动；`dag-types.ts` 加 `buildDagTransitTask` + `buildStageTask.priorIsBridge`，27 单测全过。
+
+**下次会话 TODO（优先级从高到低）**：
+1. **运行时实地验收 §12.3**：①每个 stage 之间出现「总控协调（承上启下）」气泡，内容是对上一批的综合；②后端日志中转轮 `[leader-roster] ... 注入席位交付状态` 显示上一批 ✅、未跑的 ⬜；③下一 stage 席位 task 里带的是总控承上说明（非机械摘要）；④中转轮不应真的派活（即使派了前端也忽略）。
+2. 运行时实地验收（旧）：①§12.1 后并行席位能搜索、步骤条显示；②并行 special 日志时间重叠 + `Excluded` 不含 web_search 含 write_file；③用户干预后是「总控派活」而非重跑 DAG；④最左全局侧栏 + 参与角色栏并行收起且不回弹。
+3. **✅ Phase 7 DAG 流程图可视化已完成（2026-06-07）**：见 §7.2。`DagFlowChart` 组件 + 编辑器只读预览 + Step2 执行态缩略(`dagNodeStates` 实时驱动)。
+4. （可选）串行也确定性注入上一轮交付摘要。
+
+**关键文件速查**：
+- 前端：`hooks/useStep2Orchestration.ts`（`runDagOrchestration` / `dagPlanExecutedRef` / 并行 store+flush）、`components/Step2Panel.tsx`（两列+头像条）、`components/ParallelSeatStrip.tsx`、`lib/dag-types.ts`、`lib/chain-stages.ts`、`pages/BusinessChainEditorPage.tsx`、`pages/RoundtablePlanningPage.tsx`（侧栏收起 effect + handleConfirmAgents dag 分支）、`components/BusinessChainPicker.tsx`（链条→dag）。
+- 后端：`app/gateway/roundtable_run_policy.py`（`seat_parallel`，**待放宽**）、`app/gateway/routers/multi_agent.py`（`_special_run` 读 `parallel_no_file`）、`persistence/roundtable_chains/`（`stages` 列）、`migrations/versions/20260607_03_chain_stages.py`。
+- 测试：`frontend-web` 用 esbuild 转译 `.test.ts` 后 `node --test`（项目无 vitest）；后端 `PYTHONPATH=. uv run pytest tests/test_roundtable_chain_stages.py tests/test_roundtable_run_policy.py`。
+

frontend-web/docs/roundtable-step2-sandbox-progress.md

@@ -0,0 +1,207 @@
+# 圆桌 Step 2 沙箱预览 · 开发进度
+
+> 最后更新：2026-05-27
+> 关联文档：`multi-agent-frontend-dev.md`（总览）、`multi-agent-backend-dev.md`（后端）、`multi-agent-api.md`（接口）
+> 对照参考：主聊天 `/page/workspace/chats/:threadId`（`ChatBox` + `ArtifactsProvider` + `message-group.tsx`）
+
+---
+
+## 1. 目标
+
+在 Step 2「多智能体圆桌研讨」中，当子智能体调用 `write_file` / `str_replace` / `present_files` 时，**行为与主聊天一致**：
+
+| 能力 | 主聊天 | Step 2 目标 |
+|------|--------|-------------|
+| `write_file` 流式期间自动打开右侧沙箱 | ✅ | ✅ 虚拟 URL |
+| 步骤卡里点击文件路径打开沙箱 | ✅ | ✅ |
+| 消息下方文件卡片（`present_files`）点击打开 | ✅ | ✅ `PresentFilesRow` |
+| 沙箱打开时收起 workspace 左侧栏 | ✅（`ArtifactsProvider.select`） | ✅ Step 2 左栏联动 |
+| 60/40 对话 \| 产物预览分栏 | ✅ `ChatBox` | ✅ `Step2SandboxLayout` |
+| 流式 MD 从 tool_call.args.content 预览 | ✅ 虚拟 URL + stub messages | ✅ `seatStubMessages`（双通道：`onPhaseChange` + `onUpstreamFrame`） |
+| 落盘后 HTTP 拉取真实文件 | ✅ artifacts API | ✅ `present_files` 卡片走 HTTP |
+| 草稿 reload 后历史文件可预览 | ✅ | ✅ `seatStubMessages` 一并入草稿 |
+
+---
+
+## 2. 已完成
+
+### 2.1 Step 2 布局调整
+
+| 项 | 状态 | 说明 |
+|----|------|------|
+| 推理模型下拉 | ✅ | 从右侧栏迁至 Step 2 顶栏「多智能体圆桌会商中心」右侧 |
+| 意图理解 | ✅ | 移至左侧栏顶部，支持展开/收起；收起时仅显示「目标」 |
+| 任务概览 | ✅ | 放在「人工参与」下方 |
+| 右侧栏 Step 2/3 隐藏 | ✅ | `RightSidebar` 仅在 `currentStep === 1` 渲染 |
+| 左侧栏整体收起 | ✅ | 宽度 56px；展开按钮在顶部；研讨中角色 ring + ping 动画 |
+| 沙箱打开 → 左栏收起 | ✅ | `Step2SandboxSidebarSync` 监听 `useArtifacts().open` |
+
+**主要文件**：`RoundtablePlanningPage.tsx`（`step2SidebarExpanded`、`LeftSidebar`、`Step2SandboxSidebarSync`）
+
+### 2.2 沙箱基础设施（Phase 1）
+
+| 项 | 状态 | 说明 |
+|----|------|------|
+| 路由包 `ChatRuntime` | ✅ | `WorkspaceRoutes.tsx` → `roundtable/planning` 外包 `ArtifactsProvider` |
+| 60/40 分栏壳 | ✅ | `Step2SandboxLayout.tsx`，对齐 `chat-box.tsx` |
+| `ArtifactFileDetail` / `ArtifactFileList` | ✅ | 嵌在右栏 ResizablePanel |
+| `ThreadContext` stub | ✅ | 最小 `BaseStream` stub，供 `useArtifactContent` 工作 |
+
+### 2.3 沙箱打开逻辑（Phase 2）
+
+| 项 | 状态 | 说明 |
+|----|------|------|
+| `write_file` 自动打开 | ✅ | `handleArtifactToolPhase` 在 `tool_calling` + 完整 `args.path` 时触发 |
+| 步骤卡点击打开 | ✅ | `MessageStepsCard` → `openArtifactFromStep` |
+| 虚拟 URL 机制 | ✅ | `write-file:<path>?message_id=...&tool_call_id=...`（对齐主聊天） |
+| Stub messages 注入 | ✅ | `seatStubMessages` + `upsertSeatToolCall` → `loadArtifactContentFromToolCall` |
+| 重置清理 | ✅ | `resetStep2State` 清空 artifacts / stub / deselect |
+| `present_files` 步骤点击 | ✅ | 走真实路径 `openArtifactPreview`（HTTP API） |
+
+### 2.4 上游帧兜底注入（Phase 3）
+
+| 项 | 状态 | 说明 |
+|----|------|------|
+| `onPhaseChange` 主通道 | ✅ | `tool_calling` 阶段每帧把完整 `args` 喂进 stub；首次出现 `path` 即触发自动打开 |
+| `onUpstreamFrame` 兜底通道 | ✅ | `handleUpstreamFrame` 扫描 messages-tuple 帧的 `tool_calls[]`，对 `write_file`/`str_replace` 持续 upsert `args.content`；覆盖 phase 已切走但 tool_calls 又回包的边界 |
+| 双通道幂等 | ✅ | `upsertSeatToolCall` 按 `(toolName, path)` 去重，两个通道并发写入安全 |
+
+### 2.5 `present_files` 文件卡（Phase 4）
+
+| 项 | 状态 | 说明 |
+|----|------|------|
+| 气泡下方文件卡行 | ✅ | `Step2Message` → `collectPresentedFiles` → `PresentFilesRow` |
+| 卡片样式 | ✅ | 文件名 + 扩展名徽章（FILE_EXT_LABELS），最小宽度 30/最大 50（hover 边框亮色） |
+| 点击 → HTTP 预览 | ✅ | `openArtifactPreview(agentThreadId, path)`，与步骤卡 `present_files` 走同一通道 |
+| 席位 thread 缺失保护 | ✅ | 没有 `agentThreadId` 时 disabled + tooltip |
+| 同气泡多次 present_files | ✅ | `filepaths` 顺序去重，全部聚合到一行卡片 |
+
+### 2.6 草稿持久化（Phase 5）
+
+| 项 | 状态 | 说明 |
+|----|------|------|
+| `seatStubMessages` 进 `Step2Snapshot` | ✅ | `useStep2Orchestration.ts` Step2Snapshot 新增字段 |
+| `seatStubMessages` 进 `DraftStep2Snapshot` | ✅ | `drafts.ts` 加 optional 字段，老草稿 reload 时回退到 `{}` |
+| `hydrateFromDraft` 还原 stub | ✅ | 同步写 `seatStubMessagesRef` + state，加载草稿后点击历史 write_file 步骤可直接预览 |
+| `getStep2Snapshot` 透出 stub | ✅ | `RoundtablePlanningPage.tsx` 给 `useDraftPersistence` 的 getter 加上该字段 |
+
+**主要文件**：
+
+```
+frontend-web/src/pages/WorkspaceRoutes.tsx
+frontend-web/src/roundtable-planning/hooks/useStep2Orchestration.ts
+frontend-web/src/roundtable-planning/components/Step2SandboxLayout.tsx
+frontend-web/src/roundtable-planning/components/Step2Panel.tsx
+frontend-web/src/roundtable-planning/components/MessageStepsCard.tsx
+frontend-web/src/roundtable-planning/pages/RoundtablePlanningPage.tsx
+frontend-web/src/roundtable-planning/utils/drafts.ts
+```
+
+### 2.7 与主聊天对齐的核心数据流
+
+```
+special seat SSE (streamMultiAgent)
+  ├── onPhaseChange("tool_calling", "write_file", args)
+  │     ↓
+  │   upsertSeatToolCall(seatThreadId, "write_file", args)
+  │     → seatStubMessages[seatThreadId] = [{ type:"ai", tool_calls:[{ id, name, args }] }]
+  │     ↓
+  │   buildWriteFileVirtualUrl(path, messageId, toolCallId)
+  │     → "write-file:/mnt/user-data/outputs/foo.md?message_id=...&tool_call_id=..."
+  │     ↓
+  │   openSeatVirtualArtifact(seatThreadId, virtualUrl, auto=true)
+  │     → selectArtifact(virtualUrl) + setArtifactsOpen(true)
+  │
+  └── onUpstreamFrame(frame)         ← 兜底通道
+        ↓
+      handleUpstreamFrame —— 持续 upsert tool_calls 里完整的 args（不打开沙箱）
+
+Step2SandboxLayout
+  ThreadContext.thread.messages = seatStubMessages[activeThreadId]
+  ArtifactFileDetail(filepath=virtualUrl, threadId=seatThreadId)
+    ↓
+  useArtifactContent → loadArtifactContentFromToolCall
+    → 从 thread.messages 读 tool_call.args.content（不发 HTTP）
+```
+
+**为何不用真实 path 直接预览**：流式期间文件可能尚未落盘，直接调 `/api/threads/:id/artifacts/...` 会返回 `404 {"detail":"Not Found"}`。主聊天同样用虚拟 URL 绕过此问题。
+
+---
+
+## 3. 未完成 / 待验证
+
+### 3.1 功能缺口（按优先级）
+
+| 优先级 | 项 | 状态 | 说明 |
+|--------|----|------|------|
+| P0 | 端到端回归 | ⚠️ 待验证 | 虚拟 URL + 双通道 + 文件卡 + 草稿持久化全链路尚未在浏览器里跑一遍 |
+| P2 | `str_replace` 流式编辑预览 | ❌ | 主聊天 `applyPendingTextEdit` 依赖完整 message 链；stub 未模拟 tool result / 多轮 str_replace 累加 |
+| P2 | 沙箱 `artifacts[]` 列表与虚拟 URL 混排 | ❌ | 虚拟 URL 不写入 `setArtifacts([])`；多文件切换、文件名下拉体验未完全对齐主聊天 |
+| P3 | Step 3 与沙箱衔接 | ❌ | Step 3 仍用 `HighFidelityReport` + `listSessionArtifacts`；与 Step 2 沙箱选中态无联动 |
+| P3 | 文档同步 | ❌ | `multi-agent-frontend-dev.md` 仍描述旧布局（右侧栏模型选择器等），需更新 § 布局 + 沙箱章节 |
+
+### 3.2 已知风险 / 边界
+
+1. **打开时机**：仅在 SSE 进入 `tool_calling` 且 `tool_calls[0].args` 为完整对象时触发自动打开（`multi-agent.ts` 刻意忽略 `tool_call_chunks` 的拼接 args）。若模型只发 chunks、迟迟不发完整 tool_calls，自动打开会延迟到 args 完整那一帧——与主聊天一致。
+2. **多 write_file 同气泡**：`upsertSeatToolCall` 按 `(toolName, path)` 幂等；同 path 多次 write 会更新 args，不会新建多条 stub tool_call。
+3. **leader 席位**：当前仅 special 流绑定 `agentThreadId` 并接 `onUpstreamFrame`；总控若直接 write_file，需单独接 thread id 与帧回调。
+4. **`present_files` 文件大小**：流式期间 backend 尚未给出真实大小；卡片只显示扩展名徽章，不显示 size。落盘后用户点开走 HTTP API 自然能看到完整内容。
+5. **调试日志**：控制台 `[roundtable-sandbox]` 前缀；生产环境可考虑加 `window.__ROUNDTABLE_SANDBOX_DEBUG__` 门控。
+
+---
+
+## 4. 分阶段计划（原始规划 vs 现状）
+
+| 阶段 | 内容 | 状态 |
+|------|------|------|
+| Phase 1 | `ChatRuntime` + 分栏壳 + 侧栏联动 | ✅ 完成 |
+| Phase 2 | `write_file` 自动/点击打开 + 虚拟 URL 预览 | ✅ 完成 |
+| Phase 3 | `onUpstreamFrame` 注入完整 LangGraph messages | ✅ 完成（双通道兜底） |
+| Phase 4 | `present_files` 卡片 + Step 3 文件区衔接 | ⚠️ 卡片完成；Step 3 衔接遗留 |
+| Phase 5 | 草稿 stub 持久化 + 文档更新 | ✅ stub 完成；本文档同步更新 |
+
+---
+
+## 5. 测试清单
+
+在 `/page/workspace/roundtable/planning` Step 2 下逐项勾选：
+
+- [ ] 子智能体 `write_file` 进入 `tool_calling` 后，右侧沙箱 **自动** 打开（约 100ms 延迟，对齐主聊天）
+- [ ] 沙箱标题为文件名（如 `sample-paper.md`），**不是** `{"detail":"Not Found"}`
+- [ ] 流式期间 MD 内容随 `args.content` 更新（双通道：phase 切换帧 + 兜底帧）
+- [ ] 点击 ChainOfThought 步骤「写入文件」/ 路径 chip → 手动打开同一文件
+- [ ] `present_files` 后气泡下方出现文件卡（带扩展名徽章），点击 → HTTP 预览
+- [ ] 沙箱打开时左侧「意图理解」栏 **自动收起**
+- [ ] 关闭沙箱（X）后对话区恢复全宽
+- [ ] 「新建任务」后 artifacts / 沙箱 / `seatStubMessages` 全部清空
+- [ ] 「保存草稿」→「加载草稿」后，点击历史 `write_file` 步骤可立即预览（stub 已还原）
+- [ ] 与主聊天 `/page/workspace/chats/:threadId` 对比：同一 write_file 行为一致
+
+**调试**：DevTools Console 过滤 `[roundtable-sandbox]` 或 `[stream:special:...]`。
+
+---
+
+## 6. 关键代码索引
+
+| 用途 | 路径 |
+|------|------|
+| 主聊天 write_file 虚拟 URL + 自动打开 | `src/components/workspace/messages/message-group.tsx` |
+| 主聊天 `RichFileCard`（present_files） | `src/components/workspace/messages/message-list-item.tsx` |
+| 主聊天 60/40 分栏 | `src/components/workspace/chats/chat-box.tsx` |
+| 虚拟 URL 内容加载 | `src/core/artifacts/loader.ts` → `loadArtifactContentFromToolCall` |
+| Artifacts 上下文 | `src/components/workspace/artifacts/context.tsx` |
+| Step 2 编排 + 沙箱状态 + 草稿快照 | `src/roundtable-planning/hooks/useStep2Orchestration.ts` |
+| Step 2 沙箱布局 | `src/roundtable-planning/components/Step2SandboxLayout.tsx` |
+| Step 2 文件卡 + 步骤渲染 | `src/roundtable-planning/components/Step2Panel.tsx` |
+| SSE phase 推断 + `onUpstreamFrame` | `src/roundtable-planning/api/multi-agent.ts` → `setPhase` |
+| 主页面侧栏 + 联动 | `src/roundtable-planning/pages/RoundtablePlanningPage.tsx` |
+| 草稿持久化 | `src/roundtable-planning/utils/drafts.ts`、`hooks/useDraftPersistence.ts` |
+
+---
+
+## 7. 下一步建议（给接续开发者）
+
+1. **先跑通 P0 测试清单**，确认 Phase 3/4/5 改造后无回归；重点观察双通道并发写入 stub 时 args 是否被旧帧覆盖（理论上 LangGraph 完整 tool_calls 是单调累积的，应该没问题）。
+2. **Phase 4 收尾**：把 Step 3 的 `listSessionArtifacts` / `HighFidelityReport` 接进沙箱选中态——Step 3 进入时复用 Step 2 的 `ArtifactsProvider`，让用户在 Step 3 也能预览 Step 2 留下的产物。
+3. **Phase 2 边界**：`str_replace` 多轮编辑的 stub 模拟（追加 tool result 消息让 `applyPendingTextEdit` 能 replay edit 序列），优先级低。
+4. **更新** `multi-agent-frontend-dev.md`：Step 2 布局、沙箱架构、`seatStubMessages` 数据流，避免与本文档重复——可在总览文档加一节「见 `roundtable-step2-sandbox-progress.md`」。

frontend-web/docs/ui规范-浅蓝/浅蓝色ui规范.md

@@ -0,0 +1,375 @@
+# 浅蓝色 UI 规范
+
+> 本文档由设计稿截图（`1.1 全局样式-色彩`、`1.2 全局样式-色彩附录`）识别整理而成。
+> 全部色值已与"色彩附录"编号表逐一核对，保证准确。
+
+---
+
+## 1.1 色彩体系总览
+
+调色体系分为 **主色** 与 **辅色** 两大类。每个色相按用途分为若干阶梯：
+
+| 阶梯 | 数量 | 用途 |
+| --- | --- | --- |
+| 浅色 | 3 | 用于大面积底色 |
+| 中亮色 | 6 | 用于标签、图表、提示等 |
+| 深色 | 4（+基准色，共 5 个深阶） | 用于小面积按钮、图标等 |
+| 线性渐变色 | 1 | 用于特殊装饰性小面积底色 |
+| 径向渐变色 | 1 | 用于特殊装饰性小面积底色 |
+
+> 中性色（灰阶）略有不同：浅色用于背景 / 白色文字及分割线，中亮色用于备注文字及图标，深色用于正文，且**无渐变色**。
+
+---
+
+## 主色
+
+### 主色 - 红（基准 `#CF1322`）
+
+| 用途 | 色值 |
+| --- | --- |
+| 浅色 | `#FEFAFA` · `#FEF6F6` · `#FEEDED` |
+| 中亮色 | `#FDDADC` · `#FCB5B9` · `#FA9196` · `#F86C73` · `#F74750` · `#F5222D` |
+| 深色 | `#CF1322` · `#BC0D1E` · `#A8071A` · `#820014` · `#5C0011` |
+| 线性渐变色 | `#F5222D` → `#A8071A` |
+| 径向渐变色 | `#F86C73` → `#F5222D` |
+
+### 主色 - 蓝（基准 `#0062D9`）
+
+| 用途 | 色值 |
+| --- | --- |
+| 浅色 | `#F9FCFF` · `#F4F9FF` · `#EAF4FF` |
+| 中亮色 | `#D4E9FF` · `#AAD2FF` · `#80BCFF` · `#55A6FE` · `#2B8FFE` · `#0079FE` |
+| 深色 | `#0062D9` · `#0056C6` · `#004AB3` · `#00368C` · `#002466` |
+| 线性渐变色 | `#0079FE` → `#004AB3` |
+| 径向渐变色 | `#55A6FE` → `#0079FE` |
+
+---
+
+## 辅色
+
+### 辅色 - 橙（基准 `#D97B00`）
+
+| 用途 | 色值 |
+| --- | --- |
+| 浅色 | `#FFFCF9` · `#FFFAF4` · `#FFF6EA` |
+| 中亮色 | `#FFEED4` · `#FFDDAA` · `#FFCC80` · `#FFBB55` · `#FFAA2B` · `#FF9900` |
+| 深色 | `#D97B00` · `#C66D00` · `#B35F00` · `#8C4600` · `#663000` |
+| 线性渐变色 | `#FF9900` → `#B35F00` |
+| 径向渐变色 | `#FFBB55` → `#FF9900` |
+
+### 辅色 - 绿（基准 `#1EB07F`）
+
+| 用途 | 色值 |
+| --- | --- |
+| 浅色 | `#FAFEFD` · `#F6FDFB` · `#EEFCF7` |
+| 中亮色 | `#DCF8EE` · `#BAF1DD` · `#97EBCD` · `#74E4BC` · `#52DDAB` · `#2FD69A` |
+| 深色 | `#1EB07F` · `#189D72` · `#118A65` · `#07634B` · `#043D30` |
+| 线性渐变色 | `#2FD69A` → `#118A65` |
+| 径向渐变色 | `#74E4BC` → `#2FD69A` |
+
+### 辅色 - 青蓝（基准 `#2F9ACC`）
+
+| 用途 | 色值 |
+| --- | --- |
+| 浅色 | `#FBFDFE` · `#F7FCFE` · `#EFFAFE` |
+| 中亮色 | `#E0F5FD` · `#C1EBFB` · `#A2E1F9` · `#83D7F7` · `#64CDF5` · `#45C3F3` |
+| 深色 | `#2F9ACC` · `#2788B9` · `#1E76A6` · `#115580` · `#0B3959` |
+| 线性渐变色 | `#45C3F3` → `#1E76A6` |
+| 径向渐变色 | `#83D7F7` → `#45C3F3` |
+
+### 中性色 - 灰（基准 `#222222`）
+
+| 用途 | 色值 |
+| --- | --- |
+| 浅色（背景、白色文字及分割线） | `#FFFFFF` · `#FAFAFA` · `#F5F5F5` |
+| 中亮色（备注文字及图标） | `#E8E8E8` · `#DBDBDB` · `#C1C1C1` · `#A6A6A6` · `#7F7F7F` · `#575757` |
+| 深色（正文） | `#3D3D3D` · `#222222` |
+
+---
+
+## 1.2 色彩附录（编号对照表）
+
+编号规则：`ZS` = 主色（主色调），`FS` = 辅色 / 中性色。`-01~-03` 为浅色，`-04~-09` 为中亮色，`-10~-13` 为深色，`-14` 为线性渐变色，`-15` 为径向渐变色；不带后缀的为该色相基准深色。
+
+### 主色 ZS
+
+| 编号 | 红 (ZS-001) | 编号 | 蓝 (ZS-002) |
+| --- | --- | --- | --- |
+| ZS-001 | `#CF1322` | ZS-002 | `#0062D9` |
+| ZS-001-01 | `#FEFAFA` | ZS-002-01 | `#F9FCFF` |
+| ZS-001-02 | `#FEF6F6` | ZS-002-02 | `#F4F9FF` |
+| ZS-001-03 | `#FEEDED` | ZS-002-03 | `#EAF4FF` |
+| ZS-001-04 | `#FDDADC` | ZS-002-04 | `#D4E9FF` |
+| ZS-001-05 | `#FCB5B9` | ZS-002-05 | `#AAD2FF` |
+| ZS-001-06 | `#FA9196` | ZS-002-06 | `#80BCFF` |
+| ZS-001-07 | `#F86C73` | ZS-002-07 | `#55A6FE` |
+| ZS-001-08 | `#F74750` | ZS-002-08 | `#2B8FFE` |
+| ZS-001-09 | `#F5222D` | ZS-002-09 | `#0079FE` |
+| ZS-001-10 | `#BC0D1E` | ZS-002-10 | `#0056C6` |
+| ZS-001-11 | `#A8071A` | ZS-002-11 | `#004AB3` |
+| ZS-001-12 | `#820014` | ZS-002-12 | `#00368C` |
+| ZS-001-13 | `#5C0011` | ZS-002-13 | `#002466` |
+| ZS-001-14 | `#F5222D` → `#A8071A` | ZS-002-14 | `#0079FE` → `#004AB3` |
+| ZS-001-15 | `#F86C73` → `#F5222D` | ZS-002-15 | `#55A6FE` → `#0079FE` |
+
+### 辅色 / 中性色 FS
+
+| 编号 | 橙 (FS-001) | 绿 (FS-002) | 青蓝 (FS-003) | 中性灰 (FS-004) |
+| --- | --- | --- | --- | --- |
+| FS-00n | `#D97B00` | `#1EB07F` | `#2F9ACC` | `#222222` |
+| -01 | `#FFFCF9` | `#FAFEFD` | `#FBFDFE` | `#FFFFFF` |
+| -02 | `#FFFAF4` | `#F6FDFB` | `#F7FCFE` | `#FAFAFA` |
+| -03 | `#FFF6EA` | `#EEFCF7` | `#EFFAFE` | `#F5F5F5` |
+| -04 | `#FFEED4` | `#DCF8EE` | `#E0F5FD` | `#E8E8E8` |
+| -05 | `#FFDDAA` | `#BAF1DD` | `#C1EBFB` | `#DBDBDB` |
+| -06 | `#FFCC80` | `#97EBCD` | `#A2E1F9` | `#C1C1C1` |
+| -07 | `#FFBB55` | `#74E4BC` | `#83D7F7` | `#A6A6A6` |
+| -08 | `#FFAA2B` | `#52DDAB` | `#64CDF5` | `#7F7F7F` |
+| -09 | `#FF9900` | `#2FD69A` | `#45C3F3` | `#575757` |
+| -10 | `#C66D00` | `#189D72` | `#2788B9` | `#3D3D3D` |
+| -11 | `#B35F00` | `#118A65` | `#1E76A6` | — |
+| -12 | `#8C4600` | `#07634B` | `#115580` | — |
+| -13 | `#663000` | `#043D30` | `#0B3959` | — |
+| -14 | `#FF9900` → `#B35F00` | `#2FD69A` → `#118A65` | `#45C3F3` → `#1E76A6` | — |
+| -15 | `#FFBB55` → `#FF9900` | `#74E4BC` → `#2FD69A` | `#83D7F7` → `#45C3F3` | — |
+
+> 注：中性灰（FS-004）无渐变阶，最深至 `#222222`（基准）/`#3D3D3D`（FS-004-10），用于正文文字。
+
+---
+
+# 组件规范
+
+> 以下为各组件的视觉规范与实现方式。颜色统一引用上文色值，建议在项目中先抽取为 CSS 变量 / Tailwind token，组件只引用语义化变量。
+
+## 语义化 Token 建议
+
+把色彩体系映射成语义变量，组件层只用语义名，便于换肤与维护：
+
+```css
+:root {
+  /* 品牌 / 主色（蓝） */
+  --color-primary:        #0062D9; /* 主按钮、实底选中：ZS-002 深色基准 */
+  --color-primary-hover:  #0079FE; /* 悬浮态：ZS-002-09 */
+  --color-primary-active: #0056C6; /* 按下态：ZS-002-10 */
+  --color-primary-bg:     #EAF4FF; /* 浅底选中底色：ZS-002-03 */
+  --color-primary-border: #0079FE; /* 描边选中边框 */
+
+  /* 中性 */
+  --color-text:           #3D3D3D; /* 正文：FS-004-10 */
+  --color-text-secondary: #A6A6A6; /* 次要 / 占位符：FS-004-07 */
+  --color-border:         #DBDBDB; /* 默认边框：FS-004-05 */
+  --color-bg-disabled:    #F5F5F5; /* 失效底色：FS-004-03 */
+  --color-fill-disabled:  #A6A6A6; /* 主按钮失效底色：FS-004-07 */
+  --color-surface:        #FFFFFF; /* 卡片 / 控件底 */
+}
+```
+
+> 项目使用 Tailwind v4 + shadcn，可在 `@theme` 中声明这些变量后用 `bg-primary` / `text-primary` 等使用；下文示例同时给出等价的 Tailwind 写法。
+
+---
+
+## 2.1 基础 - 按钮（Button）
+
+### 按钮尺寸
+
+| 规格 | 高度 | 圆角 | 用途 |
+| --- | --- | --- | --- |
+| 小 | **28px** | 4px | 空间小的板块内部，如表格中、卡片标题等 |
+| 正常 | **32px** | 4px | 常用按钮（默认尺寸） |
+
+水平内边距约 12–16px，字号 14px，图标与文字间距 4–8px。
+
+### 常用按钮类型
+
+| 类型 | 视觉 | 用途 |
+| --- | --- | --- |
+| 主按钮 | 实底 `--color-primary`，白字 | 一个操作区域**只能有一个**主按钮 |
+| 主按钮·失效 | 实底灰 `--color-fill-disabled`，白字 | 主按钮禁用态 |
+| 次要按钮 | 白底 + `--color-primary` 边框 + 蓝字 | 重要度低于主按钮，高于默认按钮 |
+| 默认按钮 | 白底 + `--color-border` 边框 + `--color-text` | 默认动作（取消等） |
+| 默认·失效 | `--color-bg-disabled` 底 + 浅边框 + `--color-text-secondary` | 次要/默认按钮禁用态 |
+| 文本按钮 | 无边框无底，蓝字（可加下划线） | 表格操作、文件下载等 |
+| 图标按钮 | 仅图标，可选 描边/实底/浅底 × 方形/圆形 | 增强辨识度或节省空间 |
+
+实现（Tailwind 示意）：
+
+```tsx
+// 主按钮
+<button className="h-8 px-4 rounded text-sm text-white bg-[#0062D9]
+                   hover:bg-[#0079FE] active:bg-[#0056C6]
+                   disabled:bg-[#A6A6A6] disabled:cursor-not-allowed">确定</button>
+
+// 次要按钮（次按钮）
+<button className="h-8 px-4 rounded text-sm text-[#0062D9] bg-white
+                   border border-[#0062D9] hover:bg-[#EAF4FF]">点击</button>
+
+// 默认按钮
+<button className="h-8 px-4 rounded text-sm text-[#3D3D3D] bg-white
+                   border border-[#DBDBDB] hover:border-[#0079FE] hover:text-[#0079FE]
+                   disabled:bg-[#F5F5F5] disabled:text-[#A6A6A6] disabled:border-[#DBDBDB]">取消</button>
+
+// 文本按钮
+<button className="text-sm text-[#0062D9] hover:underline">文本按钮样式</button>
+
+// 图标按钮（实底圆形）
+<button className="size-7 grid place-items-center rounded-full text-white bg-[#0062D9]
+                   hover:bg-[#0079FE]"><TrashIcon className="size-4" /></button>
+```
+
+图标按钮三种底 × 两种形状：
+- **描边**：白底 + `--color-border` 边框，图标用 `--color-text`
+- **实底**：`--color-primary` 底 + 白图标
+- **浅底**：`--color-primary-bg`（`#EAF4FF`）底 + 蓝图标
+- 形状：方形 `rounded`（4px）/ 圆形 `rounded-full`
+
+### 按钮组合
+
+| 组合 | 说明 |
+| --- | --- |
+| 文字 + 下拉按钮 | 按钮右侧带 `⌄` 箭头；有 默认 / 主按钮 两种变体 |
+| 图标 + 文字按钮 | `+ 正常`，前置图标；有 描边 / 实底 两种变体 |
+| 文本按钮 + 图标 | 蓝色文本链按钮：`更多 »` `展开 ⌄` `下一页 »|` `收起 ⌃` `|⌜ 上一页` |
+| 主按钮 + 默认按钮 | `确定`(主) `取消`(默认) `返回`(默认) 并排，间距 8–12px |
+
+### 其他状态
+
+- **悬浮状态（hover）**：主按钮悬浮时底色变亮（`--color-primary-hover` `#0079FE`），用于 Banner / 登录 / 视觉冲击强的场景。
+- **加载中（loading）**：按钮内前置旋转图标 `⟳ 加载中`，期间 `disabled` 并降低交互；用于异步操作等待反馈。
+
+```tsx
+<button className="h-8 px-4 rounded text-sm text-white bg-[#0062D9] inline-flex items-center gap-1.5" disabled>
+  <Spinner className="size-4 animate-spin" /> 加载中
+</button>
+```
+
+---
+
+## 5.9 输入 - 单选框（选择按钮 / Segmented Radio）
+
+一组互斥选项，外观为按钮组。两种排布 × 三种选中样式。
+
+### 排布方式
+
+| 排布 | 说明 |
+| --- | --- |
+| 拼接式 | 选项首尾相连，仅最外侧两角圆角，相邻共用 1px 边框 |
+| 分离式 | 选项之间留间距（约 8px），每个独立 4px 圆角，各自带完整边框 |
+
+### 选中（已选）样式 × 三种
+
+| 样式 | 已选 | 未选 |
+| --- | --- | --- |
+| 描边式 | 白底 + 蓝边框 `--color-primary` + 蓝字 | 白底 + `--color-border` 边框 + `--color-text` |
+| 浅底式 | `--color-primary-bg`(`#EAF4FF`) 底 + 蓝字 + 蓝边框 | 同上 |
+| 实底式 | `--color-primary` 实底 + 白字 | 同上 |
+
+- **带统计**：选项文字后追加计数，如 `已选(230)` / `未选(230)`，计数用次要色 `--color-text-secondary`。
+
+实现（拼接式 + 描边选中）：
+
+```tsx
+<div className="inline-flex rounded overflow-hidden border border-[#DBDBDB] divide-x divide-[#DBDBDB]">
+  {options.map((o) => (
+    <button key={o.value}
+      className={cn(
+        "h-8 px-4 text-sm bg-white",
+        value === o.value
+          ? "text-[#0062D9] ring-1 ring-inset ring-[#0079FE] z-10" // 描边选中
+          : "text-[#3D3D3D] hover:text-[#0079FE]"
+      )}>
+      {o.label}{o.count != null && <span className="text-[#A6A6A6]">({o.count})</span>}
+    </button>
+  ))}
+</div>
+```
+
+> 浅底式把选中态换成 `bg-[#EAF4FF] text-[#0062D9]`；实底式换成 `bg-[#0062D9] text-white`。
+> 分离式去掉 `divide-x` / `overflow-hidden`，外层用 `gap-2`，每个按钮单独 `rounded border`。
+
+### 按钮式页签（Tab as Button）
+
+图标 + 文字的页签型按钮：
+- **激活** 两种：描边（白底 + 蓝边框 + 蓝字）/ 实底（`--color-primary` 底 + 白字）
+- **正常**：白底 + `--color-border` 边框 + `--color-text`，前置图标
+- 结构与拼接式选择按钮一致，区别在每项前置一个功能图标。
+
+---
+
+## 5.11 输入 - 选择器（Select / Dropdown）
+
+单项输入选择，下拉单选。
+
+### 状态
+
+| 状态 | 触发框 |
+| --- | --- |
+| 占位 | `请选择` 占位文字用 `--color-text-secondary`，灰边框 `--color-border`，右侧 `⌄` |
+| 展开/聚焦 | 边框变 `--color-primary`，箭头翻转为 `⌃` |
+| 已选 | 显示选中项文字（正文色），保持聚焦时蓝边框 |
+
+### 下拉面板
+
+- 白底、圆角 4px、投影（如 `shadow-lg`），最大高度后出现滚动条
+- 选项默认 `--color-text`；**hover / 选中** 项：`--color-primary-bg`(`#EAF4FF`) 底 + `--color-primary` 文字
+- **分组**：分组标题用小号灰字 `--color-text-secondary`，组之间用 1px 分割线 `--color-border`
+
+实现示意：
+
+```tsx
+// 触发框
+<button className="h-8 w-full px-3 inline-flex items-center justify-between rounded
+                   border border-[#DBDBDB] bg-white text-sm
+                   data-[state=open]:border-[#0062D9]">
+  <span className={selected ? "text-[#3D3D3D]" : "text-[#A6A6A6]"}>{selected ?? "请选择"}</span>
+  <ChevronDown className="size-4 text-[#A6A6A6] transition-transform data-[state=open]:rotate-180" />
+</button>
+
+// 下拉项
+<li className={cn(
+  "h-9 px-3 flex items-center text-sm cursor-pointer rounded-sm",
+  active ? "bg-[#EAF4FF] text-[#0062D9]" : "text-[#3D3D3D] hover:bg-[#EAF4FF]"
+)}>{label}</li>
+
+// 分组标题
+<div className="px-3 py-1.5 text-xs text-[#A6A6A6]">分组标题1</div>
+```
+
+> 推荐直接基于 Radix `Select`（项目已有 shadcn 封装）改这些类名落地。
+
+---
+
+## 5.14 输入 - 开关（Switch）
+
+两种形态：
+
+### 1. 滑块开关（多用于表单、表格中）
+
+- **开**：胶囊底 `--color-primary`，白色圆形滑块在右，左侧白字「开」
+- **关**：胶囊底灰 `--color-text-secondary`/`#C1C1C1`，滑块在左，右侧灰字「关」
+- 切换时滑块带左右过渡动画
+
+```tsx
+<button role="switch" aria-checked={on}
+  className={cn(
+    "relative h-6 w-12 rounded-full transition-colors text-[11px] text-white",
+    on ? "bg-[#0062D9]" : "bg-[#C1C1C1]"
+  )}>
+  <span className={cn("absolute top-0.5 size-5 rounded-full bg-white transition-all",
+                       on ? "left-[26px]" : "left-0.5")} />
+  <span className={cn("absolute top-1/2 -translate-y-1/2", on ? "left-2" : "right-2 text-[#7F7F7F]")}>
+    {on ? "开" : "关"}
+  </span>
+</button>
+```
+
+### 2. 单选框作为开关（分段式）
+
+- `开 | 关` 两段式：激活段 `--color-primary` 实底白字，未激活段白底灰字 + `--color-border` 边框
+- 即 5.9 拼接式「实底选择按钮」的两选项特例
+
+```tsx
+<div className="inline-flex rounded overflow-hidden border border-[#DBDBDB]">
+  <button className={cn("h-7 px-4 text-sm", on  ? "bg-[#0062D9] text-white" : "bg-white text-[#3D3D3D]")}>开</button>
+  <button className={cn("h-7 px-4 text-sm border-l border-[#DBDBDB]", !on ? "bg-[#0062D9] text-white" : "bg-white text-[#3D3D3D]")}>关</button>
+</div>
+```

frontend-web/docs/ui规范-深蓝/00-基础-色彩字体间距.md

@@ -0,0 +1,580 @@
+# 深蓝色 UI 规范 · 00 基础（色彩 / 字体 / 阴影 / 圆角 / 间距 / 分割线）
+
+> 本文件是《深蓝色 UI 规范》拆分后的**基础篇（§1–§7）**，是全站设计令牌的唯一来源。
+> 其余分册见同目录 `README.md`；可直接 import 的变量见 `tokens.css`。
+> 跨章节 `§N` 编号全局唯一，所属文件见 README 的「§ 索引」。
+
+**本篇目录（§1–§7）**：`1` 色彩 · `2` 字体 · `3` 阴影 · `4` 圆角 · `5` 按钮 · `6` 分割线 · `7` 间距
+
+---
+
+## 1. 色彩
+
+### 1.1 标准色
+
+色彩体系由四个色系构成，每个色系分主色与辅色两组，每组按明度从浅到深编号（01 最浅，数字越大越深）。
+
+---
+
+#### 1.1.1 色系总览
+
+| 色系 | 用途定位 | 代码前缀 |
+|------|----------|----------|
+| 渐红系 | 警示、错误、强调操作 | ZS-001 |
+| 渐蓝系 | 信息、链接、次级操作 | ZS-002 |
+| 渐青系 | 成功、在线状态、数据高亮 | ZS-003 |
+| 深蓝系 | 页面背景、容器、导航底色 | ZS-004 |
+
+---
+
+#### 1.1.2 渐红系（ZS-001）
+
+用于错误提示、危险操作、重要告警。
+
+| 编号 | 色值 | 说明 |
+|------|------|------|
+| ZS-001-01 | `#FFF1F0` | 极浅红，错误背景底色 |
+| ZS-001-02 | `#FFCCC7` | 浅红，输入框错误边框 |
+| ZS-001-03 | `#FFA39E` | — |
+| ZS-001-04 | `#FF7875` | — |
+| ZS-001-05 | `#FF4D4F` | 标准红，Tag / Badge |
+| ZS-001-06 | `#F5222D` | 主色红，按钮 / 图标 |
+| ZS-001-07 | `#CF1322` | 深红，Hover 状态 |
+| ZS-001-08 | `#A8071A` | 深红，Active / Press |
+| ZS-001-09 | `#820014` | 极深红 |
+| ZS-001-10 | `#5C0011` | 最深红 |
+
+---
+
+#### 1.1.3 渐蓝系（ZS-002）
+
+用于信息提示、链接、次级按钮。
+
+| 编号 | 色值 | 说明 |
+|------|------|------|
+| ZS-002-01 | `#E6F4FF` | 极浅蓝，信息背景底色 |
+| ZS-002-02 | `#BAE0FF` | 浅蓝 |
+| ZS-002-03 | `#91CAFF` | — |
+| ZS-002-04 | `#69B1FF` | — |
+| ZS-002-05 | `#4096FF` | 标准蓝，链接 / 信息 Tag |
+| ZS-002-06 | `#1677FF` | 主色蓝，主操作按钮 |
+| ZS-002-07 | `#0958D9` | 深蓝，Hover |
+| ZS-002-08 | `#003EB3` | 深蓝，Active |
+| ZS-002-09 | `#002C8C` | 极深蓝 |
+| ZS-002-10 | `#001D6C` | 最深蓝 |
+
+---
+
+#### 1.1.4 渐青系（ZS-003）
+
+用于成功状态、在线标识、数据图表高亮。
+
+| 编号 | 色值 | 说明 |
+|------|------|------|
+| ZS-003-01 | `#E6FFFB` | 极浅青，成功背景 |
+| ZS-003-02 | `#B5F5EC` | 浅青 |
+| ZS-003-03 | `#87E8DE` | — |
+| ZS-003-04 | `#5CDBD3` | — |
+| ZS-003-05 | `#36CFC9` | 标准青，成功 Tag |
+| ZS-003-06 | `#13C2C2` | 主色青，在线点 / 图标 |
+| ZS-003-07 | `#08979C` | 深青，Hover |
+| ZS-003-08 | `#006D75` | 深青，Active |
+| ZS-003-09 | `#00474F` | 极深青 |
+| ZS-003-10 | `#002329` | 最深青 |
+
+---
+
+#### 1.1.5 深蓝系（ZS-004）
+
+用于页面背景、导航栏、侧边栏、卡片容器。这是深蓝主题的核心色系。
+
+| 编号 | 色值 | 说明 |
+|------|------|------|
+| ZS-004-01 | `#E8EDF5` | 极浅，分割线 / 禁用底色 |
+| ZS-004-02 | `#C5CFE0` | 浅，边框 |
+| ZS-004-03 | `#9BADC8` | — |
+| ZS-004-04 | `#6E88B0` | — |
+| ZS-004-05 | `#4A6491` | 中深蓝，次级文字 |
+| ZS-004-06 | `#2D4473` | 深蓝，卡片容器背景 |
+| ZS-004-07 | `#1A2F5A` | 深蓝，侧边栏背景 |
+| ZS-004-08 | `#122347` | 深蓝，导航栏背景 |
+| ZS-004-09 | `#0C1836` | 极深蓝，页面背景 |
+| ZS-004-10 | `#060E24` | 最深，全局底色 |
+
+---
+
+#### 1.1.6 功能色（主色 / 字体色 / 辅色 / 背景色）
+
+从标准色系中提取，用于具体 UI 角色指定。
+
+| 角色 | 色值 | 来源 |
+|------|------|------|
+| 主色（Primary） | `#1677FF` | ZS-002-06 |
+| 主色 Hover | `#0958D9` | ZS-002-07 |
+| 主色 Active | `#003EB3` | ZS-002-08 |
+| 正常字体色 | `#C5CFE0` | ZS-004-02 |
+| 次级字体色 | `#6E88B0` | ZS-004-04 |
+| 禁用字体色 | `#4A6491` | ZS-004-05 |
+| 辅色（Accent） | `#13C2C2` | ZS-003-06 |
+| 页面背景色 | `#0C1836` | ZS-004-09 |
+| 容器背景色 | `#1A2F5A` | ZS-004-07 |
+| 白色 | `#FFFFFF` | — |
+
+---
+
+#### 1.1.7 小面积装饰色
+
+用于图标点缀、徽标、少量强调，不用于大面积背景。
+
+| 色值 | 说明 |
+|------|------|
+| `#6388FF` | 紫蓝，图标装饰 |
+| `#F5222D` | 红色，危险徽标 |
+| `#12306C` | 深蓝，品牌点缀 |
+| `#478880` | 青绿，辅助点缀 |
+| `#950404` | 深红，重要告警点 |
+
+---
+
+#### 1.1.8 图表配色
+
+**通用图表色序**（面积较大，如柱状图、折线图、饼图）：
+
+| 序号 | 色值 |
+|------|------|
+| 1 | `#1677FF` |
+| 2 | `#13C2C2` |
+| 3 | `#4096FF` |
+| 4 | `#36CFC9` |
+| 5 | `#69B1FF` |
+| 6 | `#5CDBD3` |
+| 7 | `#91CAFF` |
+| 8 | `#87E8DE` |
+
+**小面积图表色序**（面积较小，如散点、小徽章、迷你图）：
+
+| 序号 | 色值 |
+|------|------|
+| 1 | `#4096FF` |
+| 2 | `#36CFC9` |
+| 3 | `#FF4D4F` |
+| 4 | `#FFA39E` |
+| 5 | `#6388FF` |
+| 6 | `#478880` |
+
+---
+
+#### 1.1.9 功能语义色（Functional / Status）
+
+承载「成功 / 警告 / 错误 / 信息 / 处理中」语义。其中**错误红、信息蓝、处理中青**直接复用标准色；**成功绿、警告橙**为标准色系之外的补充色（深色背景下 ZS-003 青偏冷、且无现成橙），在此正式收录。全站语义场景一律引用本表，不再各处自定义。
+
+| 语义 | 色值 | 来源 | 典型用途 |
+|------|------|------|----------|
+| 成功 / 已完成 | `#52C41A` | 补充色（绿） | 成功提示、完成状态、通过校验 |
+| 警告 / 进行中 | `#FAAD14` | 补充色（橙） | 警告提示、进行中、需注意 |
+| 错误 / 失败 | `#F5222D` | ZS-001-06 | 错误提示、删除、失败状态 |
+| 信息 / 默认 | `#1677FF` | ZS-002-06 | 信息提示、主操作、链接 |
+| 处理中 / 等待 | `#13C2C2` | ZS-003-06 | 处理中、排队、等待反馈 |
+
+> 浅底变体（Message / Alert / Tag 底色）：前景色取 16% 透明度，如成功底 `rgba(82,196,26,0.16)`、警告底 `rgba(250,173,20,0.16)`。
+> CSS Token 见 `tokens.css` 的 `--func-success / --func-warning / --func-error / --func-info / --func-processing`。
+
+---
+
+## 2. 字体
+
+### 2.1 全局样式 - 字体
+
+---
+
+#### 2.1.1 大屏页面字体规范
+
+##### 中文字体：Noto Sans S Chinese
+
+| 样式 | 使用场景 |
+|------|----------|
+| 24px Bold | 一级标题 |
+| 24px Medium | 次要一级标题 |
+| 22px Medium | 二级标题 |
+| 22px Regular | 正文 |
+| 20px Regular | 排版空间有限的正文 |
+
+##### 数字字体：D-DIN
+
+| 样式 | 使用场景 |
+|------|----------|
+| 32px Bold | 重要数据展示 |
+| 32px Regular | 普通数据展示 |
+| 26px Bold | 常规数据展示 |
+| 26px Regular | 常规数据展示 |
+
+##### 特殊数字：DS-Digital
+
+| 样式 | 使用场景 |
+|------|----------|
+| 50px Bold | 大屏主数据展示 |
+
+##### 表格字体：Arial
+
+| 样式 | 使用场景 |
+|------|----------|
+| 20px Regular | 表格横纵轴数字 |
+
+---
+
+#### 2.1.2 后台系统字体规范
+
+##### 中文字体：Noto Sans S Chinese
+
+| 样式 | 使用场景 |
+|------|----------|
+| 18px Bold | 导航、一级标题 |
+| 18px Medium | 次要一级标题 |
+| 16px Bold | 二级标题 |
+| 16px Medium | 次要二级标题 |
+| 16px Regular | 正文、按钮内部文字等 |
+| 16px Light | 次要正文 |
+
+##### 数字字体：D-DIN
+
+| 样式 | 使用场景 |
+|------|----------|
+| 26px Bold | 重要数据展示 |
+| 26px Regular | 普通数据展示 |
+| 24px Bold | 常规数据展示（小） |
+| 24px Regular | 常规数据展示（小） |
+
+##### LOGO 字体：DOUYUFont
+
+| 样式 | 使用场景 |
+|------|----------|
+| 20px 文字样式 | 页面顶部系统名称 |
+
+##### 表格数字：Arial
+
+| 样式 | 使用场景 |
+|------|----------|
+| 16px Regular | 表格横纵轴数字 |
+| 14px Regular | 表格横轴数字（空间有限） |
+
+---
+
+## 3. 阴影
+
+### 3.1 容器与卡片配色
+
+阴影组通过深浅层级叠加形成空间感：外层容器最深，内层卡片次之，边框与高亮文字使用主色或字体色。
+
+#### 3.1.1 外层容器
+
+| 角色 | 色值 | 来源 |
+|------|------|------|
+| 页面 / 最外层背景 | `#060E24` | ZS-004-10 |
+| 分栏容器背景 | `#0C1836` | ZS-004-09 |
+
+#### 3.1.2 卡片（标题 + 操作）
+
+| 角色 | 色值 | 来源 |
+|------|------|------|
+| 卡片背景 | `#122347` | ZS-004-08 |
+| 卡片边框 | `#1A2F5A` | ZS-004-07 |
+| 卡片阴影（外发光） | `rgba(22, 119, 255, 0.12)` | 基于 ZS-002-06 主色蓝 12% 透明度 |
+| 标题文字（16px Bold） | `#C5CFE0` | ZS-004-02（正常字体色） |
+| 操作按钮文字 | `#4096FF` | ZS-002-05（标准蓝，链接） |
+| 次级操作图标（✏️ / ⋯） | `#6E88B0` | ZS-004-04（次级字体色） |
+
+#### 3.1.3 卡片新增（占位卡片）
+
+虚线描边的"新增入口"卡片，用于引导用户添加内容。
+
+| 角色 | 色值 | 来源 |
+|------|------|------|
+| 卡片背景 | `#0C1836` | ZS-004-09（与外层同色，营造凹陷感） |
+| 虚线边框 | `#4096FF` | ZS-002-05 |
+| 加号图标 | `#4096FF` | ZS-002-05 |
+
+#### 3.1.4 阴影投影规则
+
+| 层级 | 阴影值 | 使用场景 |
+|------|--------|----------|
+| 一级阴影（卡片悬浮） | `0 2px 8px rgba(22, 119, 255, 0.12)` | 普通卡片 |
+| 二级阴影（hover / 强调） | `0 4px 16px rgba(22, 119, 255, 0.24)` | 卡片 hover、弹出层 |
+| 三级阴影（弹窗 / Modal） | `0 8px 32px rgba(6, 14, 36, 0.6)` | Dialog、Drawer |
+
+---
+
+## 4. 圆角
+
+### 4.1 圆角统一规范
+
+| 元素 | 圆角值 | 说明 |
+|------|--------|------|
+| 按钮 | `2px` | 所有按钮（主按钮 / 次按钮 / 文本按钮）统一使用 |
+| 卡片 | `4px` | 内容卡片、标题+操作卡片、卡片新增占位 |
+| 页面分栏框 | `4px` | 外层容器、分栏区域 |
+| 输入框 / 选择器 | `2px` | 与按钮一致，保持表单内对齐 |
+| Tag / Badge | `2px` | 与按钮一致 |
+| Modal / Drawer | `4px` | 与卡片一致 |
+
+### 4.2 按钮配色（圆角 2px）
+
+#### 4.2.1 主按钮（Primary）
+
+| 角色 | 色值 | 来源 |
+|------|------|------|
+| 背景 | `#1677FF` | ZS-002-06 |
+| 文字 | `#FFFFFF` | — |
+| Hover 背景 | `#0958D9` | ZS-002-07 |
+| Active 背景 | `#003EB3` | ZS-002-08 |
+| 禁用背景 | `#4A6491` | ZS-004-05 |
+| 禁用文字 | `#6E88B0` | ZS-004-04 |
+
+#### 4.2.2 次按钮（Outline / Default）
+
+| 角色 | 色值 | 来源 |
+|------|------|------|
+| 背景 | `transparent` | — |
+| 边框 | `#6E88B0` | ZS-004-04 |
+| 文字 | `#C5CFE0` | ZS-004-02 |
+| Hover 边框 | `#4096FF` | ZS-002-05 |
+| Hover 文字 | `#4096FF` | ZS-002-05 |
+| Active 边框 | `#1677FF` | ZS-002-06 |
+
+### 4.3 卡片与分栏（圆角 4px）
+
+| 角色 | 色值 | 来源 |
+|------|------|------|
+| 卡片背景 | `#122347` | ZS-004-08 |
+| 卡片边框 | `#1A2F5A` | ZS-004-07 |
+| 分栏框背景 | `#0C1836` | ZS-004-09 |
+| 分栏框边框 | `#1A2F5A` | ZS-004-07 |
+
+---
+
+## 5. 按钮
+
+> 全部圆角 `2px`，文字字号 14px（小尺寸）/ 14px（正常尺寸），字体 Noto Sans S Chinese Regular。
+
+### 5.1 按钮尺寸
+
+| 规格 | 高度 | 内边距 | 使用场景 |
+|------|------|--------|----------|
+| 小 | `28px` | `0 10px` | 空间小的板块内部，如表格中、卡片标题等 |
+| 正常 | `32px` | `0 14px` | 默认尺寸，所有常用按钮 |
+
+### 5.2 按钮类型与配色
+
+#### 5.2.1 主按钮（Primary）
+
+> 一个操作区域只能有一个主按钮。
+
+| 状态 | 背景 | 边框 | 文字 |
+|------|------|------|------|
+| 默认 | `#1677FF` (ZS-002-06) | — | `#FFFFFF` |
+| Hover | `#0958D9` (ZS-002-07) | — | `#FFFFFF` |
+| Active | `#003EB3` (ZS-002-08) | — | `#FFFFFF` |
+| 失效 | `rgba(22, 119, 255, 0.35)` | — | `#6E88B0` (ZS-004-04) |
+
+#### 5.2.2 默认按钮（Default / Outline）
+
+用于"取消 / 返回"等次要操作，与主按钮成对出现时主按钮在右。
+
+| 状态 | 背景 | 边框 | 文字 |
+|------|------|------|------|
+| 默认 | `transparent` | `#6E88B0` (ZS-004-04) | `#C5CFE0` (ZS-004-02) |
+| Hover | `rgba(22, 119, 255, 0.08)` | `#4096FF` (ZS-002-05) | `#4096FF` (ZS-002-05) |
+| Active | `rgba(22, 119, 255, 0.16)` | `#1677FF` (ZS-002-06) | `#1677FF` (ZS-002-06) |
+| 失效 | `transparent` | `#4A6491` (ZS-004-05) | `#4A6491` (ZS-004-05) |
+
+#### 5.2.3 文本按钮（Text）
+
+用于表格操作、文件下载等。无背景与边框，靠文字色识别。
+
+| 状态 | 文字 | 装饰 |
+|------|------|------|
+| 默认 | `#4096FF` (ZS-002-05) | 无下划线 |
+| Hover | `#1677FF` (ZS-002-06) | 显示下划线（与文字同色） |
+| Active | `#0958D9` (ZS-002-07) | 下划线 |
+| 失效 | `#4A6491` (ZS-004-05) | 无装饰 |
+
+#### 5.2.4 图标按钮（Icon-only）
+
+用于增强辨识度或节省空间。仅图标，无文字。
+
+| 变体 | 背景 | 图标颜色 |
+|------|------|----------|
+| 主色（常用） | `#1677FF` (ZS-002-06) | `#FFFFFF` |
+| 主色 Hover | `#0958D9` (ZS-002-07) | `#FFFFFF` |
+| 危险（删除等） | `#F5222D` (ZS-001-06) | `#FFFFFF` |
+| 危险 Hover | `#CF1322` (ZS-001-07) | `#FFFFFF` |
+| 透明（仅图标） | `transparent` | `#6E88B0` (ZS-004-04) → hover `#4096FF` (ZS-002-05) |
+
+### 5.3 按钮组合
+
+#### 5.3.1 文字 + 下拉按钮（含 ▾）
+
+两种填充：
+
+| 形态 | 配色规则 |
+|------|----------|
+| 默认（Outline） | 沿用 §5.2.2 默认按钮，箭头 ▾ 与文字同色 `#C5CFE0` |
+| 主色（Filled） | 沿用 §5.2.1 主按钮，箭头 ▾ 同步白色 `#FFFFFF` |
+
+#### 5.3.2 图标 + 文字按钮（如 `+ 正常`）
+
+| 形态 | 配色规则 |
+|------|----------|
+| 默认（Outline） | 沿用 §5.2.2，左侧图标颜色与文字一致 `#C5CFE0` |
+| 主色（Filled） | 沿用 §5.2.1，左侧图标与文字一致 `#FFFFFF` |
+
+#### 5.3.3 文本按钮 + 图标（"更多 »"、"展开 ⌄"、"下一页 »"、"« 上一页"）
+
+| 角色 | 色值 |
+|------|------|
+| 文字 + 图标（默认） | `#4096FF` (ZS-002-05) |
+| 文字 + 图标（Hover） | `#1677FF` (ZS-002-06) |
+| 失效 | `#4A6491` (ZS-004-05) |
+
+> 图标可在文字前或后；多个文本按钮排成一行时，间距 `16px`，无分隔符。
+
+#### 5.3.4 主按钮 + 默认按钮组合（如"确定 / 取消 / 返回"）
+
+- **排列顺序**：默认按钮在左，主按钮在右（最右侧为主操作）
+- **按钮间距**：`8px`
+- **示例**：`[ 返回 ] [ 取消 ] [ 确定 ]`
+- **配色**：主按钮沿用 §5.2.1，其余沿用 §5.2.2
+
+### 5.4 其他按钮
+
+#### 5.4.1 悬浮状态（Floating）
+
+用于 Banner / 登录 / 视觉冲击强等展示场景。配色与主按钮一致，叠加阴影抬升。
+
+| 状态 | 阴影 |
+|------|------|
+| 默认 | `0 2px 8px rgba(22, 119, 255, 0.12)`（§3.1.4 一级阴影） |
+| Hover | `0 4px 16px rgba(22, 119, 255, 0.24)`（§3.1.4 二级阴影） |
+| Active | 阴影消失，按下感 |
+
+#### 5.4.2 加载中（Loading）
+
+用于异步操作等待反馈。点击瞬间将按钮锁定，文字前显示旋转图标。
+
+| 角色 | 色值 |
+|------|------|
+| 背景 | `#1677FF` (ZS-002-06) |
+| 文字 | `#FFFFFF` |
+| 加载图标 | `#FFFFFF`，旋转动画 `1.2s linear infinite` |
+| 不可点击 | 鼠标 `cursor: not-allowed` |
+
+> 与失效态的区别：失效是"不可操作"，加载是"操作进行中"——保留品牌主色，只是不可再次触发。
+
+---
+
+## 6. 分割线
+
+> 统一线宽 `1px`，颜色全部从 ZS-004 深蓝系取色，与深色背景保持低对比度但仍可识别。
+
+### 6.1 水平分割线
+
+水平分割线常用来对不同元素内容进行分割。
+
+| 类型 | 色值 | 来源 | 样式 | 使用场景 |
+|------|------|------|------|----------|
+| 实线（默认） | `#4A6491` | ZS-004-05 | `border-top: 1px solid` | 模块间、列表项间分割 |
+| 实线（强调） | `#6E88B0` | ZS-004-04 | `border-top: 1px solid` | 主区块标题下方、卡片头部分割 |
+| 实线（弱化） | `#2D4473` | ZS-004-06 | `border-top: 1px solid` | 卡片内部、密集列表分隔 |
+| 虚线 | `#4A6491` | ZS-004-05 | `border-top: 1px dashed` | 次级 / 层级内分割，提示"非主结构" |
+| 主色实线（高亮） | `#1677FF` | ZS-002-06 | `border-top: 1px solid` | 强调分隔，少量使用（如当前激活区块底边） |
+
+### 6.2 垂直分割线
+
+垂直分割线常用来做行内分割（如导航项之间、状态指示之间、表格列头之间）。
+
+| 类型 | 色值 | 来源 | 样式 | 使用场景 |
+|------|------|------|------|----------|
+| 实线（默认） | `#4A6491` | ZS-004-05 | `border-left: 1px solid` | 行内 inline 元素分割（面包屑、操作按钮组） |
+| 实线（弱化） | `#2D4473` | ZS-004-06 | `border-left: 1px solid` | 表格列分割、紧凑布局 |
+| 虚线 | `#4A6491` | ZS-004-05 | `border-left: 1px dashed` | 多列对齐辅助、辅助参考线 |
+
+### 6.3 规格与间距
+
+| 规则 | 取值 |
+|------|------|
+| 线宽 | `1px` |
+| 水平分割线与上下元素间距 | `≥ 8px`（紧凑布局可用 `4px`） |
+| 垂直分割线与左右元素间距 | `≥ 8px`（行内紧凑 `4px`） |
+| 垂直分割线高度 | 与文字行高一致，约 `12–14px`（也可全高跟随容器） |
+| 透明度 | 必要时叠 `opacity: 0.6` 实现"更弱"层级 |
+
+### 6.4 CSS 参考
+
+```css
+/* 默认水平分割线 */
+.divider-h        { border-top: 1px solid #4A6491; }
+.divider-h-strong { border-top: 1px solid #6E88B0; }
+.divider-h-weak   { border-top: 1px solid #2D4473; }
+.divider-h-dashed { border-top: 1px dashed #4A6491; }
+.divider-h-accent { border-top: 1px solid #1677FF; }
+
+/* 垂直分割线 */
+.divider-v        { border-left: 1px solid #4A6491; height: 14px; display: inline-block; vertical-align: middle; }
+.divider-v-weak   { border-left: 1px solid #2D4473; height: 14px; display: inline-block; vertical-align: middle; }
+.divider-v-dashed { border-left: 1px dashed #4A6491; height: 14px; display: inline-block; vertical-align: middle; }
+```
+
+---
+
+## 7. 间距
+
+> 全站以 `8px (0.5rem)` 为对照基准单位，划分"密 / 疏"两个层次。所有间距取值均来自下列阶梯，禁止使用非阶梯值（如 5px、13px）。
+
+### 7.1 间距阶梯
+
+| 阶 | px | rem | 分组 | 典型场景 |
+|----|------|--------|------|----------|
+| 1 | `4px` | `0.25rem` | 密 | 图标与文字间距、Tag 内边距、紧凑徽标 |
+| 2 | `8px` | `0.5rem` | 密 | 行内元素相邻、按钮组间距、表单 label 与控件 |
+| 3 | `12px` | `0.75rem` | 密 | 表单项垂直间距、列表项内边距 |
+| 4 | `16px` | `1rem` | 密 | 卡片内容内边距、模块内分隔 |
+| 5 | `24px` | `1.5rem` | 疏 | 模块之间、Section 内边距 |
+| 6 | `32px` | `2rem` | 疏 | 卡片之间、表单组之间 |
+| 7 | `40px` | `2.5rem` | 疏 | 主区块之间、页面 Header / Footer 内边距 |
+| 8 | `56px` | `3.5rem` | 疏 | 页面段落级隔断、Banner 区域 |
+
+> "密"对应紧凑信息密度（表格、表单、卡片内部）；"疏"对应视觉呼吸（模块之间、页面整体留白）。**16px 是"密"的上限，24px 是"疏"的下限**，两者之间不应再插入自定义值。
+
+### 7.2 使用原则
+
+- **同层级一致**：同一布局层级内的间距必须使用同一阶值；多种取值会破坏节奏。
+- **就近取阶**：相邻区块的间距尽量从相邻阶梯取值（如 `16px → 24px`），跨越过多阶（如 `8px → 56px`）会让视觉断裂。
+- **密疏不混用**：一个组件内部全部用"密"，外部用"疏"，避免内/外间距颠倒。
+- **优先 8 的倍数**：除最小阶 `4px` 外，所有阶皆为 8 的倍数，方便 4/8 网格对齐。
+- **响应式按比例衰减**：移动端可整体降一阶（如 `24px → 16px`），但仍在阶梯内。
+
+### 7.3 CSS Token 建议
+
+```css
+:root {
+  --spacing-1: 4px;   /* 0.25rem */
+  --spacing-2: 8px;   /* 0.5rem  */
+  --spacing-3: 12px;  /* 0.75rem */
+  --spacing-4: 16px;  /* 1rem    */
+  --spacing-5: 24px;  /* 1.5rem  */
+  --spacing-6: 32px;  /* 2rem    */
+  --spacing-7: 40px;  /* 2.5rem  */
+  --spacing-8: 56px;  /* 3.5rem  */
+}
+```
+
+### 7.4 与已有规范的对齐
+
+| 已有规则 | 对应阶 |
+|----------|--------|
+| §4.x 卡片圆角内边距 | `--spacing-4` (16px) |
+| §5.3.4 主+默认按钮组合间距 `8px` | `--spacing-2` |
+| §5.3.3 文本按钮间距 `16px` | `--spacing-4` |
+| §6.3 分割线与上下元素间距 `≥ 8px` | `--spacing-2` 起 |
+
+---
+

frontend-web/docs/ui规范-深蓝/01-导航.md

@@ -0,0 +1,780 @@
+# 深蓝色 UI 规范 · 01 导航（§8–§13）
+
+> 《深蓝色 UI 规范》分册之一。基础令牌见 `00-基础-色彩字体间距.md`，可 import 的变量见 `tokens.css`，总目录与 §索引见 `README.md`。`§N` 编号全局唯一。
+
+**本篇目录**：`8` 导航组件 · `9` 锚点与页签 · `10` 步骤条 · `11` 面包屑 · `12` 页头 · `13` 分页
+
+---
+
+## 8. 导航组件
+
+> 适用于"大屏后台 / 控制台"类深蓝主题界面。整体结构 = 顶部导航 + 左侧分级菜单 + 多级下拉。所有颜色取自 ZS-002 / ZS-004 两个色系。
+
+### 8.1 整体结构
+
+```
+┌─ 顶部导航（Header）─ 高 56px ──────────────────────────────────────────────┐
+│ ≡ 二级菜单 二级菜单 二级菜单  〈一级菜单〉〈一级菜单〉  ⟪ XXXX系统 ⟫  〈一级菜单〉  ⟳ 时间  ⌂ 返回首页 │
+├──┬──────────────────────────────────────────────────────────────────────────┤
+│ 三│  ┌─ 四级菜单（下拉面板）──┐                                              │
+│ 级│  │ ▾ 四级菜单             │                                              │
+│ 菜│  │   ▾ 五级菜单           │                                              │
+│ 单│  │     - 六级菜单 (active)│                                              │
+│ 三│  │     - 六级菜单         │                                              │
+│ 级│  │   ▸ 五级菜单           │                                              │
+│ 菜│  │ ▸ 四级菜单             │                                              │
+│ 单│  └────────────────────────┘                                              │
+│ …│                                                                          │
+└──┴──────────────────────────────────────────────────────────────────────────┘
+```
+
+### 8.2 顶部导航（Header）
+
+#### 8.2.1 规格
+
+| 属性 | 取值 |
+|------|------|
+| 高度 | `56px` |
+| 左右 padding | `--spacing-4` (16px) |
+| 背景 | 渐变 `linear-gradient(180deg, #122347 0%, #0C1836 100%)`（ZS-004-08 → ZS-004-09） |
+| 底边 | `border-bottom: 1px solid #1A2F5A` (ZS-004-07) |
+| 阴影 | `0 2px 8px rgba(6, 14, 36, 0.6)`（§3.1.4 一级阴影变体） |
+| 文字基线 | `Noto Sans S Chinese`，垂直居中 |
+
+#### 8.2.2 二级菜单（左侧 Tabs，小号 14px）
+
+| 状态 | 文字 | 背景 | 装饰 |
+|------|------|------|------|
+| 默认 | `#6E88B0` (ZS-004-04) | `transparent` | — |
+| Hover | `#C5CFE0` (ZS-004-02) | `rgba(22,119,255,0.08)` | — |
+| 激活 | `#4096FF` (ZS-002-05) | `transparent` | 底部 `2px solid #4096FF` 高亮线 |
+
+- 字号 `14px Regular`，间距 `--spacing-3` (12px)
+- 与最左侧的"折叠菜单 ≡"图标间距 `--spacing-4` (16px)
+
+#### 8.2.3 一级菜单（中部主导航，16px 带切角装饰）
+
+| 状态 | 文字 | 装饰 |
+|------|------|------|
+| 默认 | `#C5CFE0` (ZS-004-02) | 两端切角斜边，`border: 1px solid #1A2F5A` |
+| Hover | `#4096FF` (ZS-002-05) | 切角线变 `#4096FF` |
+| 激活 | `#FFFFFF` | 切角线 `#1677FF` (ZS-002-06)，背景 `rgba(22,119,255,0.16)` |
+
+- 字号 `16px Medium`
+- 切角推荐 `clip-path: polygon(8px 0, calc(100% - 8px) 0, 100% 100%, 0 100%)`
+- 项间距 `--spacing-2` (8px)
+
+#### 8.2.4 系统标题（XXXX系统）
+
+- 字号 `20px Bold`，颜色 `#FFFFFF`
+- 字体 `DOUYUFont` 或 Noto Sans Medium
+- 左右装饰用主色蓝渐变线条：`linear-gradient(90deg, transparent 0%, #1677FF 50%, transparent 100%)`，线宽 `1px`
+- 居中相对 Header 几何中心，左右最少留 `--spacing-6` (32px) 间距给一级菜单
+
+#### 8.2.5 右侧工具区（时间 / 图标 / 返回首页）
+
+| 元素 | 字号/尺寸 | 颜色 |
+|------|----------|------|
+| 更新时间文字 | `12px Regular` | `#6E88B0` (ZS-004-04) |
+| 时间数值（数字） | `12px D-DIN Regular` | `#C5CFE0` (ZS-004-02) |
+| 工具图标（刷新/上/家） | `16px` | `#6E88B0`，hover → `#4096FF` |
+| 返回首页文字 | `14px Regular` | `#C5CFE0`，hover → `#4096FF` |
+
+- 元素间距 `--spacing-3` (12px)
+- 整体右 padding `--spacing-4` (16px)
+
+### 8.3 侧边栏（三级菜单）
+
+#### 8.3.1 规格
+
+| 属性 | 取值 |
+|------|------|
+| 宽度 | `64px`（仅图标 / 竖排文字） |
+| 背景 | `#0C1836` (ZS-004-09) |
+| 右边界 | `border-right: 1px solid #1A2F5A` (ZS-004-07) |
+| 项高度 | `64px`（与宽度一致，呈正方形） |
+| 项内间距 | 上下 `--spacing-3` (12px) |
+| 字号 | `14px Medium`，竖排（`writing-mode: vertical-rl`）或正常排两行 |
+
+#### 8.3.2 状态配色
+
+| 状态 | 背景 | 文字 | 左侧指示条 |
+|------|------|------|-----------|
+| 默认 | `transparent` | `#6E88B0` (ZS-004-04) | 无 |
+| Hover | `rgba(22,119,255,0.08)` | `#C5CFE0` (ZS-004-02) | 无 |
+| 激活 | `#1A2F5A` (ZS-004-07) | `#FFFFFF` | 左侧 `2px solid #1677FF` (ZS-002-06) |
+
+### 8.4 下拉菜单面板（四级 / 五级 / 六级）
+
+#### 8.4.1 面板规格
+
+| 属性 | 取值 |
+|------|------|
+| 背景 | `#122347` (ZS-004-08) |
+| 边框 | `1px solid #1A2F5A` (ZS-004-07) |
+| 阴影 | `0 4px 16px rgba(6, 14, 36, 0.6)`（§3.1.4 三级阴影变体） |
+| 圆角 | `4px` |
+| 内边距 | 上下 `--spacing-2` (8px) |
+| 最小宽度 | `150px` |
+
+#### 8.4.2 菜单项规格
+
+| 层级 | 缩进（padding-left） | 字号 | 展开图标 | 前缀 |
+|------|---------------------|------|----------|------|
+| 四级菜单 | `--spacing-3` (12px) | `14px Medium` | `▾ / ▸` | — |
+| 五级菜单 | `--spacing-5` (24px) | `14px Regular` | `▾ / ▸` | — |
+| 六级菜单 | `--spacing-6` (32px) | `14px Regular` | — | `-` 短横线 |
+
+- 行高 `32px`
+- 项之间无分割线（靠缩进与图标区分层级）
+
+#### 8.4.3 菜单项配色
+
+| 状态 | 背景 | 文字 | 展开图标 |
+|------|------|------|----------|
+| 默认 | `transparent` | `#C5CFE0` (ZS-004-02) | `#6E88B0` (ZS-004-04) |
+| Hover | `rgba(22,119,255,0.08)` | `#4096FF` (ZS-002-05) | `#4096FF` |
+| 激活（当前选中） | `rgba(22,119,255,0.16)` | `#4096FF` (ZS-002-05) | `#1677FF` (ZS-002-06) |
+| 父级（含激活子项） | `transparent` | `#FFFFFF` | `#1677FF` |
+| 失效 | `transparent` | `#4A6491` (ZS-004-05) | `#4A6491` |
+
+### 8.5 交互与动画
+
+| 行为 | 动效 |
+|------|------|
+| 下拉面板展开 | `transform-origin: top; transform: scaleY(0.95) → scaleY(1); opacity 0 → 1`，`200ms ease-out` |
+| 展开图标旋转 | `transform: rotate(0 → 90deg)`，`200ms ease-out` |
+| Hover 背景过渡 | `background-color 120ms ease-out` |
+| 激活底部高亮线（二级菜单） | `width 0% → 100%`，`240ms ease-out` |
+
+### 8.6 间距引用
+
+| 位置 | 取值 |
+|------|------|
+| Header 内部元素间距 | `--spacing-2 / --spacing-3` |
+| Header 与下方内容间距 | `0`（贴合，靠底边线与阴影区分） |
+| 侧边栏与下拉面板间距 | `--spacing-1` (4px) |
+| 下拉面板与触发元素间距 | `--spacing-1` (4px) |
+| 同级菜单项之间 | `0`（紧贴排列，靠 hover/active 背景区分） |
+
+---
+
+## 9. 锚点与页签
+
+> 对应"4.2 导航组件-锚点"。三类组件共用主色蓝指示当前位置：**页签 / 锚点 / 回到顶部**。
+>
+> 视觉参考：标签横向 / 标签纵向 / 锚点的三联图见设计稿「选项卡.png」——三种形态在本节均已规范化（§9.1 = 标签横纵向、§9.2 = 锚点）。
+
+### 9.1 页签（Tabs）
+
+#### 9.1.1 横向页签（下划线-横向）
+
+| 状态 | 文字 | 下划线 |
+|------|------|--------|
+| 默认 | `#C5CFE0` (ZS-004-02) | 无 |
+| Hover | `#4096FF` (ZS-002-05) | 无 |
+| 激活 | `#4096FF` (ZS-002-05) | `2px solid #4096FF`，宽度与文字齐 |
+| 失效 | `#4A6491` (ZS-004-05) | 无 |
+
+- 字号 `14px Medium`
+- 项间距 `--spacing-5` (24px)
+- 下划线与文字底部间距 `--spacing-2` (8px)
+- 容器底边可叠一条 `1px solid #1A2F5A` (ZS-004-07) 作为基线，激活态的高亮线压在上面
+
+#### 9.1.2 纵向页签（下划线-纵向）
+
+| 状态 | 文字 | 右侧指示线 |
+|------|------|-----------|
+| 默认 | `#C5CFE0` (ZS-004-02) | 无 |
+| Hover | `#4096FF` (ZS-002-05) | 无 |
+| 激活 | `#4096FF` (ZS-002-05) | 右侧 `2px solid #4096FF`，高度与文字齐 |
+| 失效 | `#4A6491` (ZS-004-05) | 无 |
+
+- 字号 `14px Medium`，项高度 `32px`
+- 项间距 `--spacing-2` (8px)
+- 容器右边可叠一条 `1px solid #1A2F5A` 基线，激活指示线压在上面
+
+### 9.2 锚点（Anchor）
+
+用于长内容页（如详情页、文档页）的章节快速跳转。
+
+#### 9.2.1 结构
+
+```
+│ 一级
+│ 一级          (active)
+│    二级
+│    二级
+│ 一级
+│ 一级
+```
+
+#### 9.2.2 规格
+
+| 属性 | 取值 |
+|------|------|
+| 容器背景 | `#122347` (ZS-004-08) 或 `transparent`（嵌入页面侧栏时） |
+| 左侧基线 | `1px solid #1A2F5A` (ZS-004-07) 通栏 |
+| 项高度 | `32px` |
+| 一级项左 padding | `--spacing-3` (12px) |
+| 二级项左 padding | `--spacing-5` (24px) |
+| 项间距 | `0`（贴合排列） |
+| 字号 | `14px Regular` |
+
+#### 9.2.3 状态配色
+
+| 状态 | 一级文字 | 二级文字 | 左侧指示条 |
+|------|----------|----------|-----------|
+| 默认 | `#C5CFE0` (ZS-004-02) | `#6E88B0` (ZS-004-04) | 无 |
+| Hover | `#4096FF` (ZS-002-05) | `#4096FF` (ZS-002-05) | 无 |
+| 激活 | `#4096FF` (ZS-002-05) | — | 左侧 `2px solid #4096FF`，覆盖容器基线 |
+| 父级（含激活子项） | `#FFFFFF` | — | — |
+
+- 激活态指示条与基线重合，宽 `2px`，色压主色蓝 `#4096FF`
+- 二级项**不单独支持激活态**：当二级被点中时，其父级一级显示激活态，左侧指示条按父级位置渲染
+
+#### 9.2.4 滚动同步
+
+| 行为 | 规则 |
+|------|------|
+| 页面滚动 | 监听锚点对应区块进入视口的相对位置，自动切换激活态 |
+| 点击锚点 | `behavior: smooth` 滚动到目标，激活指示条 `top` 过渡 `200ms ease-out` |
+| 边界处理 | 滚动到页面顶部 → 第一个锚点激活；到页尾 → 最后一个锚点激活 |
+
+### 9.3 回到顶部（BackToTop）
+
+固定在视口右下角的悬浮按钮，向上滚动到页面顶部。
+
+#### 9.3.1 规格
+
+| 属性 | 取值 |
+|------|------|
+| 形状 | 圆形 `40px × 40px`（`border-radius: 50%`） |
+| 图标 | `↑` 上箭头，`16px`，`#FFFFFF` |
+| 距视口右边 | `--spacing-5` (24px) |
+| 距视口下边 | `--spacing-6` (32px) |
+| 出现时机 | 页面 `scrollTop > 200px` 时淡入；回到顶部后淡出 |
+| 淡入/淡出 | `opacity 0 → 1` / `1 → 0`，`200ms ease-out` |
+
+#### 9.3.2 状态配色
+
+| 状态 | 背景 | 阴影 | 图标 |
+|------|------|------|------|
+| 正常（默认） | `#1677FF` (ZS-002-06) | `0 2px 8px rgba(22,119,255,0.12)` (§3.1.4 一级阴影) | `#FFFFFF` |
+| 悬停（Hover） | `#0958D9` (ZS-002-07) | `0 4px 16px rgba(22,119,255,0.24)` (§3.1.4 二级阴影) | `#FFFFFF` |
+| 点按（Active） | `#003EB3` (ZS-002-08) | 阴影消失，按下感 | `#FFFFFF` |
+| 失效 / 不显示 | — | — | 整体 `opacity: 0`，`pointer-events: none` |
+
+#### 9.3.3 悬停 Tooltip
+
+Hover 状态下方显示 `回到顶部` 提示气泡：
+
+| 属性 | 取值 |
+|------|------|
+| 文字 | `回到顶部`，`12px Regular` |
+| 文字颜色 | `#C5CFE0` (ZS-004-02) |
+| 背景 | `#1677FF` (ZS-002-06) |
+| 圆角 | `2px` |
+| 内边距 | 上下 `4px`，左右 `--spacing-2` (8px) |
+| 与按钮间距 | `--spacing-2` (8px) |
+| 出现时机 | Hover 进入 `300ms` 后显示，离开立即消失 |
+
+### 9.4 三者的差异与选用
+
+| 组件 | 主要用途 | 视觉特征 |
+|------|----------|---------|
+| 页签 | 同层级内容切换（多 Tab 互斥） | 文字 + 下划线（横/纵） |
+| 锚点 | 长页面内章节跳转 | 文字 + 左侧指示条 + 层级缩进 |
+| 回到顶部 | 长页面快速返回起点 | 圆形悬浮按钮 + 上箭头 |
+
+---
+
+## 10. 步骤条
+
+> 对应「4.7 导航组件-步骤条」。用于多步流程的进度指引，按布局方向分**横向**与**纵向**两类，按使用场景分**弹窗步骤条**、**页面步骤条**、**纵向步骤条**三种。所有颜色取自 ZS-002 主色蓝与 ZS-004 深蓝系。
+
+### 10.1 步骤节点（公共）
+
+每个步骤由「指示圆 + 标题（可选描述）」组成。指示圆按状态切换三种形态：
+
+| 状态 | 圆形外观 | 圆内符号 | 来源 |
+|------|----------|----------|------|
+| 已完成（Completed） | 描边圆，`2px solid #1677FF`，背景 `transparent` | `✓`（对勾，`#1677FF`） | ZS-002-06 |
+| 当前（Current / Active） | 实心圆，背景 `#1677FF` | 步骤数字，`#FFFFFF` | ZS-002-06 / 白 |
+| 未开始（Upcoming） | 描边圆，`1px solid #4A6491`，背景 `transparent` | 步骤数字，`#6E88B0` | ZS-004-05 / ZS-004-04 |
+| 失效（Disabled） | 描边圆，`1px solid #2D4473`，背景 `transparent` | 步骤数字，`#4A6491` | ZS-004-06 / ZS-004-05 |
+
+**指示圆规格**：
+
+| 属性 | 取值 |
+|------|------|
+| 直径 | `24px` |
+| 圆内字号 | `12px Bold`（D-DIN 或 Noto Sans Bold） |
+| 对勾图标 | `12px`，居中 |
+| 字体水平居中 | 数字 / 对勾 在圆几何中心 |
+
+**标题与描述文字**：
+
+| 元素 | 状态 | 字号 / 颜色 | 来源 |
+|------|------|-------------|------|
+| 标题 | 已完成 / 当前 | `14px Medium`，`#FFFFFF` | — |
+| 标题 | 未开始 | `14px Medium`，`#6E88B0` | ZS-004-04 |
+| 标题 | 失效 | `14px Medium`，`#4A6491` | ZS-004-05 |
+| 描述 | 已完成 / 当前 | `12px Regular`，`#C5CFE0` | ZS-004-02 |
+| 描述 | 未开始 / 失效 | `12px Regular`，`#6E88B0` → `#4A6491` | ZS-004-04 → ZS-004-05 |
+
+**连接线（步骤之间）**：
+
+| 类型 | 色值 | 来源 | 样式 |
+|------|------|------|------|
+| 已完成段（前一节点已完成） | `#1677FF` | ZS-002-06 | `1px dashed`（弹窗）/ `1px solid`（页面） |
+| 未完成段 | `#4A6491` | ZS-004-05 | `1px dashed` |
+
+> 连接线在指示圆**两侧水平居中**（横向）或**正下方垂直**（纵向）；线两端与圆外缘留 `--spacing-1` (4px) 间隙，避免线穿圆。
+
+### 10.2 弹窗步骤条（横向 · 描边圆为主）
+
+用于 Modal / Drawer 内引导多步操作的紧凑步骤条。指示圆**完成态用描边 + 对勾**而非实心，避免在弹窗背景上过于抢眼。
+
+#### 10.2.1 布局
+
+```
+( ✓ ) ┄┄┄┄┄ (●2) ┄┄┄┄┄ ( 3 ) ┄┄┄┄┄ ( 4 ) ┄┄┄┄┄ ( 5 )
+ 标题         标题         标题         标题         标题
+(描述)      (描述)       (描述)       (描述)       (描述)
+```
+
+#### 10.2.2 规格
+
+| 属性 | 取值 |
+|------|------|
+| 容器水平 padding | `--spacing-5` (24px) |
+| 指示圆 → 标题间距 | `--spacing-2` (8px) |
+| 标题 → 描述间距 | `--spacing-1` (4px) |
+| 节点之间水平间距 | 节点间距自适应等分；连接线占用中间空间 |
+| 连接线 | `1px dashed`，已完成段 `#1677FF`，未完成段 `#4A6491` |
+| 文字对齐 | 标题、描述居中对齐于指示圆下方 |
+
+#### 10.2.3 两种变体
+
+| 变体 | 适用 |
+|------|------|
+| **仅标题** | 步骤含义已经清晰（如「填写信息 / 确认 / 完成」），节省垂直空间 |
+| **标题 + 描述** | 步骤名抽象需要一行小字补充时使用 |
+
+### 10.3 页面步骤条（横向 · 实心圆 + 自定义首项标题）
+
+用于页面级流程（如「新建集群」类向导）。和弹窗步骤条相比，**已完成态指示圆改为实心填充 + 白色对勾**，视觉权重更高；首步标题可显示具体名称（如「新建集群」）而非「标题」占位。
+
+#### 10.3.1 布局
+
+```
+(✓) ────── (●2) ┄┄┄┄┄ ( 3 ) ┄┄┄┄┄ ( 4 ) ┄┄┄┄┄ ( 5 )
+新建集群     标题       标题       标题       标题
+(描述文本)  (描述文本) (描述文本) (描述文本) (描述文本)
+```
+
+#### 10.3.2 与 §10.2 弹窗步骤条的差异
+
+| 维度 | 弹窗步骤条 | 页面步骤条 |
+|------|-----------|-----------|
+| 完成态圆形 | 描边圆 + 蓝色对勾 | 实心蓝圆 + 白色对勾 |
+| 完成段连接线样式 | `1px dashed #1677FF` | `1px solid #1677FF` |
+| 标题文字号 | `14px Medium` | `14px Medium`（同） |
+| 第一项 | 通用「标题」占位 | 可显示具体名称（自定义文案） |
+
+#### 10.3.3 完成态指示圆补充
+
+| 角色 | 色值 | 来源 |
+|------|------|------|
+| 已完成圆背景 | `#1677FF` | ZS-002-06 |
+| 已完成圆内对勾 | `#FFFFFF` | — |
+| 已完成圆边框 | 无（实心） | — |
+
+### 10.4 纵向步骤条
+
+用于侧栏 / 详情页内的纵向流程指引。两种变体——「仅标题」与「标题 + 描述」。
+
+#### 10.4.1 布局
+
+```
+仅标题:                       标题 + 描述:
+
+(✓) 新建集群                   (✓) 新建集群
+ ┊                                  描述文本描述
+(●2) 标题                      ┊
+ ┊                             (●2) 标题
+( 3 ) 标题                          描述文本描述
+ ┊                             ┊
+( 4 ) 标题                     ( 3 ) 标题
+                                    描述文本描述
+                               ┊
+                               ( 4 ) 标题
+                                    描述文本描述
+```
+
+#### 10.4.2 规格
+
+| 属性 | 取值 |
+|------|------|
+| 指示圆 → 标题水平间距 | `--spacing-2` (8px) |
+| 节点垂直间距（仅标题） | `--spacing-5` (24px)，圆心到圆心 |
+| 节点垂直间距（标题 + 描述） | `--spacing-6` (32px)，圆心到圆心 |
+| 标题 → 描述间距 | `--spacing-1` (4px) |
+| 连接线位置 | 上下两个指示圆**正下方垂直**，居中于圆心 |
+| 连接线样式 | `1px dashed`，已完成段 `#1677FF`，未完成段 `#4A6491` |
+| 文字左对齐 | 标题与描述左对齐，与指示圆右侧对齐基线 |
+
+#### 10.4.3 与横向步骤条共用规则
+
+- 指示圆三态规格沿用 §10.1
+- 已完成态默认用**描边 + 对勾**（与 §10.2 弹窗一致）；若纵向步骤条用于页面级主流程，可切换为 §10.3 的实心圆变体
+
+### 10.5 交互与动画
+
+| 行为 | 动效 |
+|------|------|
+| 步骤切换（next） | 当前圆 `background: transparent → #1677FF`，`200ms ease-out`；同时上一步圆 `border-color: #4A6491 → #1677FF`，再用 `200ms` 切换为对勾图标淡入 |
+| 步骤切换（prev / 回退） | 反向，未完成态恢复 `#4A6491` 边框，圆内数字淡入 |
+| 连接线高亮 | 完成段 `border-color: #4A6491 → #1677FF`，`240ms ease-out` |
+| Hover 节点（可点击） | 圆边框色暂时变 `#4096FF` (ZS-002-05)，标题文字 `#4096FF`，`120ms ease-out`；不可点击节点（未来步骤）无 hover |
+| 点击节点 | 节点必须**已完成**才能点（回看），否则视为禁用；点击合法节点触发 `step:change` 事件 |
+
+### 10.6 状态机与可达性
+
+| 当前步 = N | 节点 i 的状态 |
+|-----------|----------------|
+| `i < N` | Completed（已完成，可点回看） |
+| `i === N` | Current（当前，不可点） |
+| `i > N` | Upcoming（未开始，不可点） |
+| `i.disabled` | Disabled（被显式禁用，例如条件未满足） |
+
+**键盘导航**：
+- `Tab` 顺序在「已完成」节点之间流转，跳过 `Current / Upcoming / Disabled`
+- 焦点节点圆外加 `2px solid #4096FF` 焦点环（`outline`，`offset 2px`）
+
+**屏幕阅读器**：
+- 指示圆 `role="img"`，`aria-label="已完成第 N 步"` / `"当前第 N 步"` / `"未开始第 N 步"`
+- 容器 `role="list"`，节点 `role="listitem"`
+- 当前节点额外 `aria-current="step"`
+
+### 10.7 CSS Token 参考
+
+```css
+:root {
+  /* 步骤条节点 */
+  --step-circle-size: 24px;
+  --step-circle-current-bg: #1677FF;       /* ZS-002-06 */
+  --step-circle-current-text: #FFFFFF;
+  --step-circle-done-border: #1677FF;      /* ZS-002-06 */
+  --step-circle-done-icon: #1677FF;        /* 弹窗变体 */
+  --step-circle-done-bg-page: #1677FF;     /* 页面变体:实心 */
+  --step-circle-done-icon-page: #FFFFFF;
+  --step-circle-upcoming-border: #4A6491;  /* ZS-004-05 */
+  --step-circle-upcoming-text: #6E88B0;    /* ZS-004-04 */
+  --step-circle-disabled-border: #2D4473;  /* ZS-004-06 */
+  --step-circle-disabled-text: #4A6491;    /* ZS-004-05 */
+
+  /* 连接线 */
+  --step-line-done: #1677FF;               /* 已完成段 */
+  --step-line-upcoming: #4A6491;           /* 未完成段:ZS-004-05 */
+
+  /* 文字 */
+  --step-title-active: #FFFFFF;
+  --step-title-inactive: #6E88B0;          /* ZS-004-04 */
+  --step-desc-active: #C5CFE0;             /* ZS-004-02 */
+  --step-desc-inactive: #6E88B0;           /* ZS-004-04 */
+}
+```
+
+### 10.8 三种步骤条的选用决策
+
+| 场景 | 选择 |
+|------|------|
+| Modal / Drawer 内多步表单 | §10.2 弹窗步骤条（描边圆，紧凑） |
+| 页面级向导（独占大区域） | §10.3 页面步骤条（实心圆，视觉重） |
+| 侧栏 / 详情页纵向流程 | §10.4 纵向步骤条 |
+| 步骤数 ≤ 3 且无描述 | 优先「仅标题」变体 |
+| 步骤名抽象需补充说明 | 用「标题 + 描述」变体 |
+| 步骤数 > 7 | 不推荐用步骤条，改用「锚点」（§9.2）或分页 |
+
+---
+
+## 11. 面包屑
+
+> 对应「4.3 导航组件-面包屑」。用于显示当前位置在整个站点层级中的路径，配合「← 返回」按钮支持逐级回溯。颜色取自 ZS-002 主色蓝与 ZS-004 深蓝系。
+
+### 11.1 标准形态
+
+容器顶部带一个独立的容器 / 边框包裹：
+
+```
+🏠 | 概况 / 总概况
+```
+
+带「返回」按钮的层级形态（一级到四级）：
+
+```
+一级:   ← 返回 │ 现在位置
+二级:   ← 返回 │ 上一级位置 / 现在位置
+三级:   ← 返回 │ 上二级位置 / 上一级位置 / 现在位置
+四级:   ← 返回 │ 上三级位置 / 上二级位置 / 上一级位置 / 现在位置
+```
+
+### 11.2 规格
+
+| 属性 | 取值 |
+|------|------|
+| 容器高度 | `40px` |
+| 容器背景 | `#0C1836` (ZS-004-09) |
+| 容器底边 | `1px solid #1A2F5A` (ZS-004-07) |
+| 容器水平 padding | `--spacing-4` (16px) |
+| 字号 | `14px Regular` |
+| 元素间距（图标 / 文字 / 分隔符之间） | `--spacing-2` (8px) |
+| 「返回」与首段路径之间分隔符 `│` | `1px solid #4A6491`，高度 `14px` |
+
+### 11.3 配色
+
+| 角色 | 色值 | 来源 | 备注 |
+|------|------|------|------|
+| Home 图标 🏠 | `#4096FF` | ZS-002-05 | 默认主色，hover → `#1677FF` (ZS-002-06) |
+| 「← 返回」图标 + 文字 | `#4096FF` | ZS-002-05 | 链接样式，hover 显示下划线 |
+| 历史路径文字（可点击） | `#4096FF` | ZS-002-05 | 同链接配色 |
+| 当前位置文字（最后一段） | `#FFFFFF` | — | 加粗 `14px Medium`，不可点击 |
+| 分隔符 `/` | `#4A6491` | ZS-004-05 | 静态、不可点 |
+| 分隔符 `│`（返回按钮与路径之间） | `#4A6491` | ZS-004-05 | 同上 |
+| Hover 路径项 | `#1677FF` | ZS-002-06 | 文字色 + 下划线 |
+| 失效路径项（无对应页） | `#4A6491` | ZS-004-05 | `cursor: not-allowed` |
+
+### 11.4 交互规则
+
+- **点击「← 返回」**：逐步向上返回一级（等同浏览器 back）
+- **点击文字路径**：快速跳回到对应任意上级页面
+- **当前位置**（最后一段）：不响应点击，仅作展示
+- **层级建议**：尽可能不超过 **4 级**；超过 4 级会让面包屑过长，应改用侧栏 / 锚点辅助
+
+### 11.5 与导航的关系
+
+面包屑**不替代**主导航（§8）：
+
+- 主导航 = 「我能去哪些地方」（站点结构）
+- 面包屑 = 「我当前在哪里」（路径回溯）
+
+两者并存时，面包屑紧贴页面主内容区顶部，位于主导航下方、页头（§12）上方。
+
+### 11.6 CSS 参考
+
+```css
+.breadcrumb {
+  display: flex;
+  align-items: center;
+  height: 40px;
+  padding: 0 var(--spacing-4);
+  background: #0C1836;
+  border-bottom: 1px solid #1A2F5A;
+  font-size: 14px;
+  gap: var(--spacing-2);
+}
+.breadcrumb-back     { color: #4096FF; cursor: pointer; }
+.breadcrumb-back:hover { color: #1677FF; text-decoration: underline; }
+.breadcrumb-sep-bar  { width: 1px; height: 14px; background: #4A6491; }
+.breadcrumb-sep      { color: #4A6491; }
+.breadcrumb-link     { color: #4096FF; cursor: pointer; }
+.breadcrumb-link:hover { color: #1677FF; text-decoration: underline; }
+.breadcrumb-current  { color: #FFFFFF; font-weight: 500; }
+```
+
+---
+
+## 12. 页头
+
+> 对应「4.6 导航组件-分页」上半段示意。用于页面主内容区顶部、面包屑下方，承载页面标题与可选的说明 / Tabs。共有 4 种变体。
+
+### 12.1 通用规格
+
+| 属性 | 取值 |
+|------|------|
+| 容器高度 | `56px`（仅标题）/ `64px`（含 Tabs） |
+| 背景 | `#0C1836` (ZS-004-09) |
+| 底边 | `1px solid #1A2F5A` (ZS-004-07) |
+| 水平 padding | `--spacing-5` (24px) |
+| 文字基线 | 垂直居中 |
+
+### 12.2 四种变体
+
+#### 12.2.1 基础页头
+
+只有标题：
+
+```
+页头标题
+```
+
+| 角色 | 色值 / 字号 | 来源 |
+|------|-------------|------|
+| 标题 | `18px Bold`，`#FFFFFF` | — |
+
+#### 12.2.2 页头 + 说明
+
+标题后跟一段灰色说明文字：
+
+```
+页头标题  （这是一句简要说明）
+```
+
+| 角色 | 色值 / 字号 | 来源 |
+|------|-------------|------|
+| 标题 | `18px Bold`，`#FFFFFF` | — |
+| 说明文字 | `14px Regular`，`#6E88B0` | ZS-004-04 |
+| 标题 → 说明间距 | `--spacing-3` (12px) | — |
+
+说明用半角圆括号包裹，颜色与括号一致（不要让括号比文字更醒目）。
+
+#### 12.2.3 页头 + 说明 icon
+
+标题后跟一个可悬停查看说明的图标：
+
+```
+页头标题  ⓘ
+```
+
+| 角色 | 色值 / 字号 | 来源 |
+|------|-------------|------|
+| 标题 | `18px Bold`，`#FFFFFF` | — |
+| 说明 icon `ⓘ` 或 `?` | `16px`，`#6E88B0` | ZS-004-04 |
+| Icon hover | `#4096FF` | ZS-002-05 |
+| 标题 → 图标间距 | `--spacing-2` (8px) | — |
+
+Hover 弹出 Tooltip（沿用 §9.3.3 Tooltip 配色），承载完整说明文字。
+
+#### 12.2.4 分 Tabs 页头
+
+标题位置直接放横向页签（沿用 §9.1.1 横向页签配色），点击切换右侧主内容区：
+
+```
+标题   标题   标题
+─────
+```
+
+| 复用规则 | 说明 |
+|----------|------|
+| Tab 配色 | 完全沿用 §9.1.1 横向页签 |
+| Tab 字号 | `16px Medium`（页头位置比一般 tab 略大） |
+| Tab 间距 | `--spacing-5` (24px) |
+| 激活态下划线 | `2px solid #4096FF`，宽与文字齐 |
+
+### 12.3 与右侧操作区的组合
+
+页头右侧常承载主操作按钮（「+ 新建」、「导出」等）。规则：
+
+- 按钮组靠右对齐，右 padding 与左 padding 一致 (`--spacing-5`)
+- 多按钮排列顺序参照 §5.3.4（默认按钮在左、主按钮在右），按钮间距 `--spacing-2`
+- Tabs 页头中右侧操作区与 Tabs 同高居中
+
+---
+
+## 13. 分页
+
+> 对应「4.6 导航组件-分页」下半段。三种形态——**正常分页 / 精简分页 / 导航式分页**——按页面信息量与可用空间选用。
+
+### 13.1 正常分页
+
+承载大列表，提供页码、跳转、每页条数选择：
+
+```
+共 240 项   < ① 2 3 4 5 … 24 >   每页 [10▾] 条   前往 [   ] 页
+```
+
+#### 13.1.1 元素配色与规格
+
+| 元素 | 字号 / 色值 | 来源 / 说明 |
+|------|-------------|-------------|
+| 「共 N 项」总数文字 | `14px Regular`，`#6E88B0` | ZS-004-04 |
+| 页码按钮（默认） | `14px Regular`，`#C5CFE0`，背景 `transparent` | ZS-004-02 |
+| 页码按钮（hover） | `#4096FF`，背景 `rgba(22,119,255,0.08)` | ZS-002-05 |
+| 页码按钮（激活/当前页） | `#FFFFFF`，背景 `#1677FF`（实心圆） | ZS-002-06 |
+| 页码按钮（失效） | `#4A6491`，背景 `transparent` | ZS-004-05 |
+| 左右翻页箭头 `<` `>` | `14px`，`#6E88B0`，hover → `#4096FF` | ZS-004-04 → ZS-002-05 |
+| 翻页箭头失效（首/末页） | `#4A6491` | ZS-004-05 |
+| 省略号 `…` | `#6E88B0` | ZS-004-04，静态展示，不可点 |
+| 每页条数下拉 `[10▾]` | 沿用 §14.1 输入框规格 | 高度 `28px`，宽 `60px` |
+| 「前往 N 页」输入框 | 沿用 §14.1 输入框规格 | 高度 `28px`，宽 `48px` |
+
+#### 13.1.2 页码按钮规格
+
+| 属性 | 取值 |
+|------|------|
+| 形状 | 圆形 `28px × 28px`（`border-radius: 50%`） |
+| 默认背景 | `transparent` |
+| 当前页背景 | `#1677FF` (ZS-002-06)，实心圆，白色数字 |
+| 字号 | `14px Regular`（数字 D-DIN 或 Noto Sans） |
+| 项间距 | `--spacing-1` (4px) |
+
+#### 13.1.3 元素间距
+
+| 区段 | 间距 |
+|------|------|
+| 「共 N 项」→ 翻页区 | `--spacing-4` (16px) |
+| 翻页区内（箭头 / 页码） | `--spacing-1` (4px) |
+| 翻页区 → 每页下拉 | `--spacing-5` (24px) |
+| 每页下拉 → 前往输入 | `--spacing-4` (16px) |
+
+### 13.2 精简分页
+
+承载弹窗 / 表格紧凑场景，只暴露「当前页 / 总页数」与左右翻页：
+
+```
+共 1 项   < [ 1 ] / 10 >
+```
+
+#### 13.2.1 规格
+
+| 元素 | 配色 / 备注 |
+|------|------------|
+| 「共 N 项」 | 同 §13.1.1 |
+| `<` `>` 翻页箭头 | 同 §13.1.1 |
+| `[ 1 ]` 当前页输入框 | 沿用 §14.1 输入框规格，高 `28px`，宽 `40px`，居中文字 |
+| `/ N` 总页数 | `14px Regular`，`#6E88B0` (ZS-004-04) |
+| 元素间距 | `--spacing-2` (8px) |
+
+#### 13.2.2 与正常分页的差异
+
+| 维度 | 正常分页 | 精简分页 |
+|------|----------|----------|
+| 页码 | 点击式数字列表 | 输入框 + 总页数文字 |
+| 跳转方式 | 点击数字 / 前往输入 | 直接修改输入框 |
+| 每页条数 | 暴露下拉 | 不暴露（默认值由调用方决定） |
+| 适用 | 列表 / 表格主内容区 | 弹窗、抽屉、卡片内嵌列表 |
+
+### 13.3 导航式分页
+
+承载长文 / 详情页的「上一篇 / 下一篇」式翻页，只有方向，不暴露页码：
+
+```
+下一页  »
+«   上一页
+```
+
+#### 13.3.1 规格
+
+| 元素 | 配色 / 备注 |
+|------|------------|
+| 「下一页」/「上一页」文字 + 箭头 | `14px Regular`，`#4096FF` (ZS-002-05) |
+| Hover | `#1677FF` (ZS-002-06) + 下划线 |
+| 失效（首/末篇） | `#4A6491` (ZS-004-05)，`cursor: not-allowed` |
+| 箭头位置 | `下一页 »`（箭头在后）/ `« 上一页`（箭头在前） |
+| 文字 → 箭头间距 | `--spacing-2` (8px) |
+| 两个按钮纵向排列时项间距 | `--spacing-3` (12px) |
+
+### 13.4 三种分页的选用决策
+
+| 场景 | 选择 |
+|------|------|
+| 后台列表 / 表格 | §13.1 正常分页 |
+| Modal / Drawer 内嵌列表 | §13.2 精简分页 |
+| 详情页前后翻 | §13.3 导航式分页 |
+| 列表少于 1 页（项数 ≤ pageSize） | **不显示**分页 |
+| 项数明确但页码可能很多（>50 页） | 用正常分页 + 隐藏中间页码（`...` 省略） |
+
+---
+

frontend-web/docs/ui规范-深蓝/04-图表.md

@@ -0,0 +1,573 @@
+# 深蓝色 UI 规范 · 04 图表（§35–§41）
+
+> 《深蓝色 UI 规范》分册之一。基础令牌见 `00-基础-色彩字体间距.md`，可 import 的变量见 `tokens.css`，总目录与 §索引见 `README.md`。`§N` 编号全局唯一。
+
+**本篇目录**：`35` 图表通用规范 · `36` 柱状图 · `37` 折线图 · `38` 甘特图 · `39` 环形图 · `40` 关系图/散点图 · `41` 图表色值
+
+---
+
+## 35. 图表通用规范（Chart 基础）
+
+> 对应设计稿「8. 图表」系列（柱状图 / 折线图 / 甘特图）。本节先约定**所有图表共用**的容器、标题、坐标轴、网格、图例、Tooltip、配色与空状态；§36 起按图表类型补充各自细则。配色一律取自 §1.1.8 图表配色与 §1.1.5 深蓝系，不另造色。
+
+### 35.1 图表容器
+
+| 属性 | 取值 | 来源 |
+|------|------|------|
+| 背景 | `#0C1836` (ZS-004-09)，嵌入卡片时随 §22 卡片 `#122347` | §3.1 |
+| 圆角 | `4px` | §4.1 |
+| 内边距 | `--spacing-5` (24px) | §7.1 |
+| 多图并排间距 | `--spacing-6` (32px) | §7.1 |
+| 边框（可选） | `1px solid #1A2F5A` (ZS-004-07) | — |
+
+### 35.2 图表标题
+
+设计稿中标题统一为「**主色蓝竖条 ▌ + 文字**」的小标题样式。
+
+| 元素 | 规格 | 来源 |
+|------|------|------|
+| 左侧竖条 | `3px × 14px`，`#1677FF` (ZS-002-06)，圆角 `1px` | §1.1.6 |
+| 竖条 → 文字间距 | `--spacing-2` (8px) | §7.1 |
+| 标题文字 | `16px Bold`，`#FFFFFF`（或 `#C5CFE0`） | §2.1.2 |
+| 标题 → 图表区间距 | `--spacing-4` (16px) | §7.1 |
+| 副标题 / 单位 | `12px Regular`，`#6E88B0` (ZS-004-04) | — |
+
+> 部分卡片标题不带竖条（如「标题（BW）」「数据采集XXX」），此时直接用 `16px Bold #C5CFE0`，与 §22 卡片标题一致。
+
+### 35.3 坐标轴
+
+| 元素 | 色值 / 规格 | 来源 |
+|------|-------------|------|
+| 轴线（X / Y 基线） | `1px solid #2D4473` (ZS-004-06) | §6.1 |
+| 刻度文字（轴标签） | `12px Regular`，`#6E88B0` (ZS-004-04) | — |
+| 轴标题 / 类目名（如「类型」「2012」） | `12px Regular`，`#4096FF` (ZS-002-05) 或 `#6E88B0` | — |
+| 刻度线（tick） | 通常隐藏，仅留网格线 | — |
+| 轴名称单位 | `12px`，`#6E88B0`，置于轴末端 | — |
+
+### 35.4 网格线（splitLine）
+
+| 类型 | 色值 | 样式 | 使用场景 |
+|------|------|------|----------|
+| 主网格（默认） | `#2D4473` (ZS-004-06) | `1px dashed` | 柱状 / 折线的 Y 向参考线 |
+| 弱化网格 | `#1A2F5A` (ZS-004-07) | `1px dashed` | 密集图表、次要参考 |
+
+> 深色背景下网格一律用**虚线**且低对比，避免抢戏；纵向类目方向通常不画网格。
+
+### 35.5 图例（Legend）
+
+| 属性 | 取值 | 来源 |
+|------|------|------|
+| 位置 | 右上角（多数）或顶部居中 | — |
+| 色块（marker） | `10px` 方块 / 圆点，取系列色 | §1.1.8 |
+| 色块 → 文字间距 | `--spacing-1` (4px) | §7.1 |
+| 图例文字 | `12px Regular`，`#C5CFE0` (ZS-004-02) | — |
+| 项间距 | `--spacing-3` (12px) | §7.1 |
+| 未选中态（点击隐藏系列） | 色块 + 文字置灰 `#4A6491` (ZS-004-05) | §1.1.5 |
+
+### 35.6 Tooltip（悬浮提示）
+
+鼠标悬停时跟随的浮层（如折线图「1月10日 异常率12.9%」、「5.32」）。
+
+| 属性 | 取值 | 来源 |
+|------|------|------|
+| 背景 | `rgba(12,24,54,0.92)`（ZS-004-09 92%） | §3.1 |
+| 边框 | `1px solid #1A2F5A` (ZS-004-07) | — |
+| 圆角 | `4px` | §4.1 |
+| 阴影 | `0 4px 16px rgba(6,14,36,0.6)` | §3.1.4 |
+| 内边距 | 上下 `--spacing-2`，左右 `--spacing-3` | §7.1 |
+| 标题行（日期 / 类目） | `12px Medium`，`#FFFFFF` | — |
+| 数值行 | `12px Regular`，色块（系列色）+ 名称 `#6E88B0` + 数值 `#C5CFE0` | — |
+| 指示线（axisPointer） | `1px dashed #4096FF` (ZS-002-05)，或半透明竖向高亮带 `rgba(22,119,255,0.12)` | §6.1 |
+
+> 设计稿中数据点 hover 常显示一个**实心小标签**（如圆点 + 数值 `5.32`）：标签背景 `#122347`，文字 `#FFFFFF`，圆点取系列色，圆角 `2px`。
+
+### 35.7 数据点与标记
+
+| 元素 | 规格 | 来源 |
+|------|------|------|
+| 折线拐点（默认） | 不显示或 `2px` 实心点 | — |
+| 折线拐点（hover / 强调） | `空心圆`，描边 `2px` 系列色，填充 `#0C1836`，直径 `6px` | — |
+| 高亮竖带（选中区间） | `rgba(22,119,255,0.12)` 矩形，无边框 | §3.1 |
+
+### 35.8 图表配色引用
+
+| 用途 | 色序 | 来源 |
+|------|------|------|
+| 多系列（面积大：柱 / 折线 / 饼） | `#1677FF → #13C2C2 → #4096FF → #36CFC9 → #69B1FF → #5CDBD3 → #91CAFF → #87E8DE` | §1.1.8 通用图表色序 |
+| 小面积（散点 / 迷你图 / 徽标） | `#4096FF → #36CFC9 → #FF4D4F → #FFA39E → #6388FF → #478880` | §1.1.8 小面积色序 |
+| 语义系列（成功 / 警告 / 错误） | 绿 `--func-success` / 橙 `--func-warning` / 红 `#F5222D` | §27.4 / §1.1.2 |
+
+> 设计稿柱状图出现的「绿(Paper) / 橙(Project) / 蓝(Book)」三系列，对应**语义化分类**：绿取 §27.4 成功绿、橙取 §27.4 警告橙、蓝取主色 `#1677FF`；若为无语义的并列分类，应改用通用图表色序避免误读。
+
+### 35.9 空状态 / 加载
+
+| 状态 | 表现 |
+|------|------|
+| 加载中 | 图表区居中显示旋转图标 `#4096FF` + 文字「加载中…」`12px #6E88B0`（沿用 §5.4.2） |
+| 无数据 | 居中占位插画 / 文字「暂无数据」`14px #6E88B0` |
+
+---
+
+## 36. 柱状图（Column / Bar）
+
+> 对应设计稿「8.1 图表-柱状图」。涵盖**堆叠柱 / 分组柱 / 条形图（横向）/ 排行进度条**四种形态。容器、坐标轴、网格、图例、Tooltip 全部沿用 §35。
+
+### 36.1 通用规格
+
+| 属性 | 取值 | 来源 |
+|------|------|------|
+| 柱体圆角 | 顶部 `2px`（堆叠柱仅最顶段圆角） | §4.1 |
+| 柱宽 | 类目宽度的 `40%~60%` |  — |
+| 同组柱间距 | `--spacing-1` (4px) | §7.1 |
+| 类目（组）间距 | 自适应等分 | — |
+| 数值标签（可选） | `12px Regular`，`#C5CFE0`，置柱顶上方 `--spacing-1` | — |
+
+### 36.2 堆叠柱状图（如「标题」Paper/Project/Book）
+
+| 元素 | 配色 | 来源 |
+|------|------|------|
+| 系列 1（Book / 底段） | `#69B1FF` (ZS-002-04) 或主色 `#1677FF` | §1.1.3 |
+| 系列 2（Project / 中段） | `--func-warning`（橙） | §27.4 |
+| 系列 3（Paper / 顶段） | `--func-success`（绿） | §27.4 |
+| 段间分隔 | `1px` 容器底色 `#0C1836` 描边，制造堆叠缝隙 | — |
+| Y 轴类目标签「类型」 | `12px`，`#4096FF` (ZS-002-05) | §35.3 |
+
+### 36.3 分组柱状图（如「标题（BW）」「标题」双系列）
+
+| 元素 | 配色 | 来源 |
+|------|------|------|
+| 系列依次取色 | 通用图表色序 `#1677FF / #13C2C2 / #4096FF …` | §1.1.8 |
+| 设计稿 BW 三色变体 | 蓝 `#69B1FF` / 绿 `--func-success` / 橙 `--func-warning` | §35.8 |
+| 双系列变体 | 蓝 `#69B1FF`(ZS-002-04) + 橙 `--func-warning` | — |
+
+### 36.4 条形图（横向，如「标题」x 轴 0–400）
+
+| 属性 | 取值 | 来源 |
+|------|------|------|
+| 方向 | 水平，类目在 Y 轴、数值在 X 轴 | — |
+| 条体颜色 | `#69B1FF` (ZS-002-04)（单系列）或图表色序 | §1.1.3 |
+| 条体圆角 | 右端 `2px` | §4.1 |
+| 类目标签「类型」 | 左对齐，`12px #6E88B0` | §35.3 |
+| X 轴刻度 | `0 / 100 / 200 / 300 / 400`，`12px #6E88B0` | §35.3 |
+
+### 36.5 排行进度条（如「数据采集XXX」TOP1–5）
+
+横向「标签 + 渐变进度条 + 数值」的榜单形态。
+
+```
+TOP1  项目任务名称一                          15,465
+■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■▓▓▓▓▓▓▓▓
+TOP2  项目任务名称二                          15,234
+■■■■■■■■■■■■■■■■■■■■■■■■■▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
+```
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 排名 + 名称（TOPn 项目任务名称） | `14px Regular`，`#C5CFE0` (ZS-004-02) | — |
+| 数值（右对齐） | `16px D-DIN Regular`，`#FFFFFF` | §2.1.2 |
+| 进度条高度 | `8px`，圆角 `4px` | §4.1 |
+| 进度填充 | 渐变 `linear-gradient(90deg, #1677FF 0%, #13C2C2 100%)`（主色蓝→主色青） | §1.1.8 |
+| 进度轨道（底槽） | `#1A2F5A` (ZS-004-07) | §1.1.5 |
+| 行间距 | `--spacing-4` (16px) | §7.1 |
+| 名称行 → 进度条间距 | `--spacing-2` (8px) | §7.1 |
+
+### 36.6 交互
+
+| 行为 | 动效 |
+|------|------|
+| 入场 | 柱体由 `0` 向目标高度 / 长度增长，`scaleY/scaleX 0→1`，`400ms ease-out`，按系列依次 `60ms` 错峰 |
+| Hover 柱 | 该柱亮度 `+8%`，弹出 §35.6 Tooltip，axisPointer 高亮该类目竖带 | 
+| Hover 进度条 | 数值放大或显示绝对值 Tooltip | 
+
+---
+
+## 37. 折线图（Line / Area）
+
+> 对应设计稿「8.2 图表-折线图」与「8.3 多系列折线」。涵盖**迷你面积图 / 单线（含异常点 Tooltip）/ 长时序面积图（带缩略轴）/ 多系列折线**。容器、轴、网格、图例、Tooltip 沿用 §35。
+
+### 37.1 线条与面积
+
+| 元素 | 规格 | 来源 |
+|------|------|------|
+| 线宽 | `2px` | — |
+| 线条颜色 | 取图表色序，单线默认 `#1677FF` (ZS-002-06) | §1.1.8 |
+| 平滑 | `smooth`（曲线）或折线，按数据性质选用 | — |
+| 面积填充（单线） | 自顶向下渐变 `rgba(22,119,255,0.32) → rgba(22,119,255,0)` | §3.1 |
+| 拐点 | 默认隐藏，hover 显示空心圆（§35.7） | — |
+
+### 37.2 迷你面积图（如左上「图表标题」+ 已选/未选 标签）
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 顶部切换标签（已选 / 未选） | §29 标签：选中 `#1677FF` 实心白字 / 未选 `transparent` + `1px #6E88B0` 边、`#6E88B0` 字 | §29 |
+| 线条 | `2px #4096FF` (ZS-002-05) | — |
+| 面积渐变 | `rgba(64,150,255,0.32) → 0` | — |
+| 当前值标签（如 `59.32`） | 实心小牌 `#122347` 背景 / `#FFFFFF` 文字，圆角 `2px`，定位于末端点 | §35.6 |
+| 轴标签（日期） | `12px #6E88B0` | §35.3 |
+
+### 37.3 单线异常点图（如中部「5-1…5-12」+「1月10日 异常率12.9%」）
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 主线 | `2px #1677FF` | — |
+| 面积渐变 | `rgba(22,119,255,0.32) → 0` | — |
+| 选中竖带 | `rgba(22,119,255,0.12)` 矩形高亮当前 X 区间 | §35.7 |
+| 异常点标记 | 空心圆 `6px`，描边 `#FAAD14`（警告橙），填充 `#0C1836` | §27.4 |
+| Tooltip（日期 + 指标） | §35.6；指标行如「异常率 12.9%」用 `--func-warning` 橙强调 | §35.6 |
+| Y 轴（0–2500） | `12px #6E88B0`，虚线网格 `#2D4473` | §35.3 / §35.4 |
+
+### 37.4 长时序面积图 + 缩略轴（如底部「图表标题」1986–2024）
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 主线 | `2px #36CFC9`（标准青）或 `#4096FF` | §1.1.4 |
+| 面积渐变 | `rgba(54,207,201,0.24) → 0` | — |
+| 数据点标签（如 `2.43`） | 实心小牌（§35.6），定位于选中点上方 | — |
+| 缩略轴（dataZoom，右下迷你图） | 缩略折线 `#4A6491`；滑窗手柄 `#1677FF`，选中区 `rgba(22,119,255,0.16)` | §1.1.5 / §1.1.6 |
+| X 轴年份 | `12px #6E88B0`，密集时隔项显示 | §35.3 |
+
+### 37.5 多系列折线图（如「图表标题」XXX/XXX/都是/无反应）
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 图例（顶部居中） | 方块 marker + 文字，项间距 `--spacing-3` | §35.5 |
+| 系列 1（XXX） | 红 `#FF4D4F` (ZS-001-05) | §1.1.2 |
+| 系列 2（XXX） | 蓝 `#1677FF` (ZS-002-06) | §1.1.3 |
+| 系列 3（都是） | 橙 `--func-warning` | §27.4 |
+| 系列 4（无反应） | 绿 `--func-success` 或青 `#36CFC9` | §27.4 / §1.1.4 |
+| 线宽 | `2px`，多系列**不填充面积**（避免互相遮挡） | — |
+| 拐点 | 全程显示 `4px` 空心圆（描边系列色，填充 `#0C1836`） | §35.7 |
+| 选中竖带 + Tooltip | hover 竖带 `rgba(22,119,255,0.12)`，Tooltip 列出各系列值（如 `5.32`） | §35.6 |
+| Y 轴（0–10） / X 轴（年份） | `12px #6E88B0`，横向虚线网格 `#2D4473` | §35.3 / §35.4 |
+
+### 37.6 交互
+
+| 行为 | 动效 |
+|------|------|
+| 入场 | 线条沿路径绘制 `stroke-dashoffset` 动画，`600ms ease-out`；面积同步淡入 |
+| Hover | 显示 §35.6 Tooltip + 竖向 axisPointer 高亮带；对应拐点放大为空心圆 |
+| 图例点击 | 切换系列显隐，隐藏态图例置灰 `#4A6491`（§35.5） |
+| 缩略轴拖拽 | 主图 X 轴范围实时联动，`100ms` 节流 |
+
+---
+
+## 38. 甘特图（Gantt）
+
+> 对应设计稿「甘特图」。以时间为横轴、任务行为纵轴的进度条排期图。深蓝背景上以**交替行底纹 + 渐变任务条 + 箭头收尾**呈现，配色取 §1.1.8 图表色序与语义色。
+
+### 38.1 结构
+
+```
+        1  2  3 … 15 16 17 …            31     ← 时间刻度表头
+ Jan  ▐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▶                      ← 任务条（带箭头收尾）
+ Feb         ▐▓▓▓▓▓▓▓▓▓▶
+ Mar      ▐▓▓▓▓▓▓▓▶
+ …
+ Dec               ▐▓▓▓▓▓▓▓▓▓▓▓▶
+ ● Lorem ipsum 1   ● Lorem ipsum 2   …          ← 底部图例
+```
+
+### 38.2 表格框架
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 容器背景 | `#0C1836` (ZS-004-09) | §35.1 |
+| 时间刻度表头（1–31 / 月） | `12px Regular`，`#C5CFE0` (ZS-004-02) | §35.3 |
+| 行标签（Jan…Dec） | `14px Regular`，`#C5CFE0` | — |
+| 行高 | `28px`，行间距 `--spacing-1` (4px) | §7.1 |
+| 行底纹（轨道） | `#122347` (ZS-004-08)，整行通栏，圆角 `2px` | §1.1.5 |
+| 行底纹（隔行可选） | 奇偶交替 `#122347` / `#0F1C3D` | — |
+| 列分隔（可选） | `1px dashed #1A2F5A` (ZS-004-07) | §6.2 |
+
+### 38.3 任务条
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 条高 | `16px`，垂直居中于行内 | — |
+| 圆角 | `2px`（左端）；右端收**箭头**三角表示方向 | §4.1 |
+| 填充 | 沿条向右渐变（系列色 `0%` → 同色 70% 透明 `100%`），叠加斜纹/点纹理增强层次 | §1.1.8 |
+| 纹理 | `repeating-linear-gradient(45deg, rgba(255,255,255,0.06) 0 4px, transparent 4px 8px)` | — |
+| 箭头收尾 | 与条同色实心三角，`6px`，指向时间推进方向 | — |
+| 进度（可选） | 条内再叠一段高饱和系列色表示完成比例 | — |
+
+### 38.4 任务分类配色（对应底部图例 Lorem ipsum 1–5）
+
+| 图例 | 圆点 / 任务条主色 | 来源 |
+|------|------------------|------|
+| Lorem ipsum 1 | 橙 `--func-warning` | §27.4 |
+| Lorem ipsum 2 | 红 `#FF4D4F` (ZS-001-05) | §1.1.2 |
+| Lorem ipsum 3 | 青绿 `#36CFC9` (ZS-003-05) | §1.1.4 |
+| Lorem ipsum 4 | 浅蓝 `#91CAFF` (ZS-002-03) | §1.1.3 |
+| Lorem ipsum 5 | 主色蓝 `#1677FF` (ZS-002-06) | §1.1.3 |
+
+### 38.5 图例与表头
+
+| 元素 | 规格 | 来源 |
+|------|------|------|
+| 底部图例圆点 | `10px` 圆形，取 §38.4 分类色 | §35.5 |
+| 图例文字 | `14px Regular`，`#C5CFE0` | — |
+| 图例项间距 | `--spacing-5` (24px) | §7.1 |
+| 表头 → 首行间距 | `--spacing-3` (12px) | §7.1 |
+
+### 38.6 交互
+
+| 行为 | 动效 |
+|------|------|
+| 入场 | 任务条由左端起点向右展开 `scaleX 0→1`（`transform-origin:left`），`400ms ease-out`，按行错峰 `60ms` |
+| Hover 任务条 | 整条亮度 `+8%`，弹出 §35.6 Tooltip（任务名 / 起止日期 / 进度） |
+| Hover 行 | 行底纹由 `#122347` → `#1A2F5A` (ZS-004-07) | 
+| 今日线（可选） | 一条 `1px dashed #4096FF` (ZS-002-05) 竖线标注当前日期 | §6.2 |
+
+### 38.7 CSS Token 参考（§35–§38 共用）
+
+```css
+:root {
+  /* 图表容器与标题 */
+  --chart-bg:            #0C1836;   /* ZS-004-09 */
+  --chart-title-bar:     #1677FF;   /* ZS-002-06 标题竖条 */
+  --chart-title-text:    #FFFFFF;
+  --chart-subtitle:      #6E88B0;   /* ZS-004-04 */
+
+  /* 坐标轴与网格 */
+  --chart-axis-line:     #2D4473;   /* ZS-004-06 */
+  --chart-axis-label:    #6E88B0;   /* ZS-004-04 */
+  --chart-axis-cat:      #4096FF;   /* ZS-002-05 类目名 */
+  --chart-grid:          #2D4473;   /* ZS-004-06 虚线网格 */
+  --chart-grid-weak:     #1A2F5A;   /* ZS-004-07 */
+
+  /* 图例 / Tooltip */
+  --chart-legend-text:   #C5CFE0;   /* ZS-004-02 */
+  --chart-legend-off:    #4A6491;   /* ZS-004-05 未选中 */
+  --chart-tooltip-bg:    rgba(12,24,54,0.92);
+  --chart-tooltip-border:#1A2F5A;   /* ZS-004-07 */
+  --chart-tooltip-title: #FFFFFF;
+  --chart-tooltip-value: #C5CFE0;
+  --chart-axispointer:   #4096FF;   /* ZS-002-05 */
+  --chart-highlight-band:rgba(22,119,255,0.12);
+
+  /* 通用图表色序（面积大） */
+  --chart-c1: #1677FF;  --chart-c2: #13C2C2;  --chart-c3: #4096FF;  --chart-c4: #36CFC9;
+  --chart-c5: #69B1FF;  --chart-c6: #5CDBD3;  --chart-c7: #91CAFF;  --chart-c8: #87E8DE;
+
+  /* 小面积图表色序 */
+  --chart-s1: #4096FF;  --chart-s2: #36CFC9;  --chart-s3: #FF4D4F;
+  --chart-s4: #FFA39E;  --chart-s5: #6388FF;  --chart-s6: #478880;
+
+  /* 排行进度条（§36.5） */
+  --rank-bar-fill:   linear-gradient(90deg, #1677FF 0%, #13C2C2 100%);
+  --rank-bar-track:  #1A2F5A;       /* ZS-004-07 */
+  --rank-value:      #FFFFFF;
+
+  /* 甘特图（§38） */
+  --gantt-track:     #122347;       /* ZS-004-08 行底纹 */
+  --gantt-row-hover: #1A2F5A;       /* ZS-004-07 */
+  --gantt-c1: #FAAD14;  /* 警告橙 */
+  --gantt-c2: #FF4D4F;  /* ZS-001-05 */
+  --gantt-c3: #36CFC9;  /* ZS-003-05 */
+  --gantt-c4: #91CAFF;  /* ZS-002-03 */
+  --gantt-c5: #1677FF;  /* ZS-002-06 */
+  --gantt-today:     #4096FF;       /* ZS-002-05 今日线 */
+}
+```
+
+> 项目当前未引入图表库；若后续接入 ECharts，可将以上 token 注入主题（`backgroundColor` / `axisLine.lineStyle.color` / `splitLine.lineStyle` / `color[]` 色序 / `tooltip.backgroundColor` 等），保持与本规范一致。
+>
+> **关于多系列填充色**：§36–§38 表格中标注的系列色用于说明语义映射；**实际多系列图表的系列填充色一律以 §41 图表色值（设计稿 8.7）为准**——即淡色系 `#FA9196 / #FFCC80 / #97EBCD / #A2E1F9 / #80BCFF …`，按系列数量取对应色序。§1.1.8 的高彩度色序仅用于需要强对比的强调场景（如单色进度条渐变、KPI 高亮）。
+
+---
+
+## 39. 环形图（Donut / Ring）
+
+> 对应设计稿「8.3 图表-环形图」。中心带总量数字的占比环图，按分类数量分**三环 / 四环 / 五环 / 六环 / 七环 / 八环**等变体。环段配色取 §41 图表色值（淡色系列），中心总量与引导标签取深蓝系字体色。
+
+### 39.1 结构
+
+```
+        三环 / 四环 …（标题）
+        ╭──────────╮
+   Media│          │Social
+   28%  │  34801   │ 36%
+        │ XXX总量  │
+        ╰──────────╯
+          News 28%
+```
+
+### 39.2 环体规格
+
+| 属性 | 取值 | 来源 |
+|------|------|------|
+| 外径 | 容器短边的 `60%~70%` | — |
+| 内径（中空比） | 外径的 `62%`（环宽约 `38%`） | — |
+| 环段间隙 | `2px`（用容器底色 `#0C1836` 描边分隔） | §35.1 |
+| 环段圆角 | `2px`（段端微圆角，可选） | §4.1 |
+| 环段配色 | 按分类数取 §41 对应「N 色」色序 | §41 |
+| 起始角 / 方向 | 顶部 `90°` 起，顺时针 | — |
+
+### 39.3 中心与标签
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 中心主数值（如 `34801`） | `26px Bold D-DIN`，`#FFFFFF` | §2.1.2 |
+| 中心说明（如 `XXX总量`） | `12px Regular`，`#6E88B0` (ZS-004-04) | — |
+| 引导标签名（如 `Social`） | `12px Regular`，`#C5CFE0` (ZS-004-02) | — |
+| 引导标签占比（如 `36%`） | `12px Regular`，`#FFFFFF` 或对应环段色 | — |
+| 引导线 | `1px solid #4A6491` (ZS-004-05) 折线，从环段引至外侧标签 | §6.1 |
+| 变体标题（三环 / 四环…） | `14px Medium`，`#C5CFE0`，居中于图上方 | §35.2 |
+
+### 39.4 交互
+
+| 行为 | 动效 |
+|------|------|
+| 入场 | 环段沿顺时针扫出 `0°→终值`，`600ms ease-out`，按段错峰 `60ms` |
+| Hover 环段 | 该段沿半径外扩 `4px`（`offset`），中心数值切换为该段值 + 占比，弹出 §35.6 Tooltip |
+| 图例点击 | 切换分类显隐，其余环段占比按比例重算 |
+
+---
+
+## 40. 关系图 / 散点图（Network / Scatter）
+
+> 对应设计稿「8.6 图表-散点图」「关系图」。用于展示账号、节点间关系的力导向网络图与散点分布。深蓝背景上以**发光节点 + 渐隐连线 + 平台聚类**呈现，节点配色取主色蓝 / 警告橙 / 危险红做分类，节点尺寸映射权重。
+
+### 40.1 节点（Node）
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 形状 | 圆形（普通节点）/ 头像圆（账号节点，`2px` 描边）/ 六边形（聚合节点） | — |
+| 直径 | `8px ~ 40px`，按权重（连接数 / 数值）线性映射 | — |
+| 分类色 A（本方 / 主） | `#1677FF` (ZS-002-06) | §1.1.3 |
+| 分类色 B（异常 / 外部） | `--func-warning`（橙） | §27.4 |
+| 分类色 C（高危 / 标红） | `#FF4D4F` (ZS-001-05) | §1.1.2 |
+| 节点发光（重点节点） | `0 0 12px` 同色 40% 透明外发光 | §3.1 |
+| 节点文字（数值 / 名称） | `12px Regular`，`#FFFFFF`（节点内）/ `#C5CFE0`（节点外） | — |
+| 中心 / 焦点节点 | 加大直径 + 强发光，橙色 `--func-warning` 高亮 | — |
+
+### 40.2 连线（Edge）
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 线宽 | `1px`（普通）/ `2px`（强关系） | — |
+| 颜色 | `#4A6491` (ZS-004-05) 半透明，或取**起点节点分类色** 40% 透明 | §1.1.5 |
+| 渐隐 | 由中心向外渐隐（`opacity 0.6 → 0.15`），弱化边缘视觉噪声 | — |
+| 方向（有向） | 末端箭头 `4px`，同线色 | — |
+| 高亮态（hover 节点时） | 关联边升为节点分类色满饱和、`2px`，无关边降至 `opacity 0.08` | — |
+
+### 40.3 散点图（Scatter，纯坐标分布）
+
+| 元素 | 规格 / 配色 | 来源 |
+|------|-------------|------|
+| 散点 | 实心圆 `6px ~ 16px`（尺寸可映射第三维） | — |
+| 配色 | 小面积色序（§41 或 §1.1.8 小面积），分类着色 | §41 |
+| 坐标轴 / 网格 | 沿用 §35.3 / §35.4 | §35 |
+| 气泡变体 | 半透明填充 `35%` + `1px` 同色描边，避免重叠遮挡 | — |
+
+### 40.4 平台聚类与图例（如 Facebook / Twitter / 微博 / TikTok）
+
+| 元素 | 规格 | 来源 |
+|------|------|------|
+| 聚类标签 | 平台名 `14px Medium`，对应聚类主色（如蓝 / 橙 / 红） | — |
+| 聚类辅文 | 数值 `12px Regular`，`#6E88B0` | — |
+| 图例（XXX / XXX） | 方块 marker + 文字，置右下角 | §35.5 |
+| 更新提示（如「近30分钟更新数据」） | `12px Regular`，`#6E88B0`，右下角 | — |
+
+### 40.5 控制区（关系图侧栏）
+
+设计稿左侧含「选择目标」下拉 + 分类勾选列表（主页发帖 / 群组发帖 / 私信 / 点赞 / 转发 / 帖子评论 / Pages内容 / 目标的主页帖子）+「添加账号 / 全选账号」按钮。
+
+| 元素 | 规格 | 来源 |
+|------|------|------|
+| 「选择目标」下拉 | 沿用 §15 选择器 | §15 |
+| 分类列表项 | `14px Regular`，前缀分类色圆点 `8px`，沿用 §16 多选 | §16 |
+| 「添加账号」 | §5.2.2 默认按钮（含 `+` 图标） | §5.3.2 |
+| 「全选账号」 | §5.2.3 文本按钮 | §5.2.3 |
+| 刷新图标（右上 ⟳） | `16px`，`#6E88B0`，hover `#4096FF` | §8.2.5 |
+
+### 40.6 交互
+
+| 行为 | 动效 |
+|------|------|
+| 力导向布局 | 节点入场后力导向收敛，`tick` 动画 `~800ms` 后静止 |
+| Hover 节点 | 高亮关联边与邻接节点（§40.2），其余降透明；弹出 §35.6 Tooltip（节点名 / 类型 / 指标） |
+| 点击节点 | 居中聚焦该节点并展开其一度关系；可下钻 |
+| 缩放 / 平移 | 滚轮缩放 `0.5×~3×`，拖拽平移画布 |
+| 拖拽节点 | 可手动拖拽固定节点位置 |
+
+---
+
+## 41. 图表色值（Chart Palette · 多系列色序）
+
+> 对应设计稿「8.7 图表-色值」。这是**全站图表多系列填充的权威色序**（淡色系，深蓝背景上柔和、区分度高）。按系列数量从「三色」到「十色」各有固定取色顺序——系列数为 N 时直接取「N 色」整行，**不要自行截取或乱序**。如需超过十色或特殊场景，由 UI 设计师按整体风格补充。
+
+### 41.1 基础色板
+
+| 色名 | 色值 | 色相 |
+|------|------|------|
+| 粉红 | `#FA9196` | 红 |
+| 橙红 | `#FCA58F` | 橙红 |
+| 橙 | `#FDB887` | 橙 |
+| 浅橙 | `#FFCC80` | 黄橙 |
+| 黄绿 | `#DCD69A` | 黄绿 |
+| 浅绿 | `#BAE1B3` | 绿 |
+| 青绿 | `#97EBCD` | 青绿 |
+| 浅青 | `#9EE4EA` | 青 |
+| 浅蓝 | `#A2E1F9` | 天蓝 |
+| 蓝 | `#80BCFF` | 蓝 |
+
+### 41.2 按系列数取色序
+
+| 系列数 | 取色顺序 |
+|--------|----------|
+| 三色 | `#FA9196` · `#97EBCD` · `#80BCFF` |
+| 四色 | `#FA9196` · `#FFCC80` · `#97EBCD` · `#A2E1F9` |
+| 五色 | `#FA9196` · `#FFCC80` · `#97EBCD` · `#A2E1F9` · `#80BCFF` |
+| 六色 | `#FA9196` · `#FFCC80` · `#BAE1B3` · `#97EBCD` · `#A2E1F9` · `#80BCFF` |
+| 七色 | `#FA9196` · `#FCA58F` · `#FFCC80` · `#BAE1B3` · `#97EBCD` · `#A2E1F9` · `#80BCFF` |
+| 八色 | `#FA9196` · `#FCA58F` · `#FDB887` · `#FFCC80` · `#BAE1B3` · `#97EBCD` · `#A2E1F9` · `#80BCFF` |
+| 九色 | `#FA9196` · `#FCA58F` · `#FDB887` · `#FFCC80` · `#DCD69A` · `#BAE1B3` · `#97EBCD` · `#A2E1F9` · `#80BCFF` |
+| 十色 | `#FA9196` · `#FCA58F` · `#FDB887` · `#FFCC80` · `#DCD69A` · `#BAE1B3` · `#97EBCD` · `#9EE4EA` · `#A2E1F9` · `#80BCFF` |
+
+> 规律：色序整体沿「红 → 橙 → 黄绿 → 绿 → 青 → 蓝」色相环渐变铺开；系列数增加时在中间插入过渡色，**首色恒为 `#FA9196`、末色恒为 `#80BCFF`**，保证冷暖两端锚定不变。
+
+### 41.3 与既有规范的关系
+
+| 色序 | 用途 | 来源 |
+|------|------|------|
+| §41 淡色系列（本节） | 图表**多系列填充**（柱 / 折线 / 环形 / 散点分类）默认色序 | 设计稿 8.7 |
+| §1.1.8 通用图表色序（高彩度） | 强对比强调：单色渐变进度条、KPI 高亮、需要醒目的单系列 | §1.1.8 |
+| §27.4 / §1.1.2 语义色 | 带语义的系列（成功 / 警告 / 错误 / 信息） | §27.4 |
+
+> 三者优先级：**有语义 → 用语义色；多分类并列 → 用 §41；需强调单值 → 用 §1.1.8 高彩度**。§36–§40 中标注的具体系列色为语义示例，实际并列分类应回落到本节色序。
+
+### 41.4 CSS Token 参考
+
+```css
+:root {
+  /* §41 图表多系列色板（淡色系，设计稿 8.7） */
+  --chart-p-red:      #FA9196;
+  --chart-p-redorange:#FCA58F;
+  --chart-p-orange:   #FDB887;
+  --chart-p-amber:    #FFCC80;
+  --chart-p-olive:    #DCD69A;
+  --chart-p-green:    #BAE1B3;
+  --chart-p-teal:     #97EBCD;
+  --chart-p-cyan:     #9EE4EA;
+  --chart-p-skyblue:  #A2E1F9;
+  --chart-p-blue:     #80BCFF;
+}
+```
+
+```js
+// 按系列数取色序（接入 ECharts 时用作 option.color）
+export const CHART_PALETTES = {
+  3:  ['#FA9196', '#97EBCD', '#80BCFF'],
+  4:  ['#FA9196', '#FFCC80', '#97EBCD', '#A2E1F9'],
+  5:  ['#FA9196', '#FFCC80', '#97EBCD', '#A2E1F9', '#80BCFF'],
+  6:  ['#FA9196', '#FFCC80', '#BAE1B3', '#97EBCD', '#A2E1F9', '#80BCFF'],
+  7:  ['#FA9196', '#FCA58F', '#FFCC80', '#BAE1B3', '#97EBCD', '#A2E1F9', '#80BCFF'],
+  8:  ['#FA9196', '#FCA58F', '#FDB887', '#FFCC80', '#BAE1B3', '#97EBCD', '#A2E1F9', '#80BCFF'],
+  9:  ['#FA9196', '#FCA58F', '#FDB887', '#FFCC80', '#DCD69A', '#BAE1B3', '#97EBCD', '#A2E1F9', '#80BCFF'],
+  10: ['#FA9196', '#FCA58F', '#FDB887', '#FFCC80', '#DCD69A', '#BAE1B3', '#97EBCD', '#9EE4EA', '#A2E1F9', '#80BCFF'],
+}
+```
+
+---
+

frontend-web/docs/ui规范-深蓝/05-页面范例.md

@@ -0,0 +1,320 @@
+# 深蓝色 UI 规范 · 05 页面范例（§42–§44）
+
+> 《深蓝色 UI 规范》分册之一。基础令牌见 `00-基础-色彩字体间距.md`，可 import 的变量见 `tokens.css`，总目录与 §索引见 `README.md`。`§N` 编号全局唯一。
+
+**本篇目录**：`42` 表单弹窗范例 · `43` 卡片列表页 · `44` 数据概览仪表盘
+
+---
+
+## 42. 表单弹窗范例（添加 / 编辑标题）
+
+> 对应设计稿「添加/编辑标题」弹窗（截图 ui-25）。这是 §21 弹出式窗口在「专项 / 标题录入」场景下的落地范例：容器 / 遮罩 / 标题栏 / 底部按钮全部沿用 §21，本节补充截图中出现而 §21 未单列的两个原子——**复合输入行**（输入框 + 行内下拉 + 行内按钮）与**行内「添加项」实心按钮**（+ 类别一 / + 类别二），并给出完整表单项清单。配色从 §1.1.2 渐红系（必填星号）、§1.1.3 渐蓝系（ZS-002，主色 / 下拉 / 按钮）、§1.1.5 深蓝系（ZS-004，label / 边框 / 容器）取。
+
+### 42.1 整体布局
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│                     添加/编辑标题                          ✕    │  ← 标题居中 + 关闭
+│  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  │  ← 发光分割线
+│                                                                │
+│ * 专项名称  [请输入内容         ] [一键导入历史专项模板▾] [预览] │  ← 复合输入行
+│ * 专项简介  [请输入内容                                      ]  │
+│ * 国家地区  [                                             ▾ ]  │
+│ * 涉及类别  [ + 类别一 ]  [ + 类别二 ]                          │  ← 行内添加按钮
+│ * 显示指数  [请选择                                       ▾ ]  │
+│                                                                │
+│                      [ 取消 ]   [ 保存 ]                        │  ← 底部居中
+└──────────────────────────────────────────────────────────────┘
+```
+
+### 42.2 容器与标题（沿用 §21）
+
+| 元素 | 取值 | 来源 |
+|------|------|------|
+| 遮罩 / 容器 / 圆角 / 阴影 | 全部沿用 §21.1 | §21.1 |
+| 容器宽度 | 大档 `800px`（复合输入行需要横向空间） | §21.1 |
+| 标题文字 | `添加/编辑标题`，`20px Bold`，`#FFFFFF`，居中 | §21.2 |
+| 标题发光分割线 | `linear-gradient(90deg, transparent, #1677FF, transparent)`，`1px` 高 | §8.2.4 / §21.2 |
+| 关闭 `✕` | `16px`，`#6E88B0` (ZS-004-04)，hover `#4096FF` (ZS-002-05) | §21.2 |
+
+### 42.3 表单项（左 label + 右控件，沿用 §21.4）
+
+| 行 | label | 控件 | 复用 |
+|----|-------|------|------|
+| 1 | `* 专项名称` | 复合输入行（见 §42.4） | §42.4 |
+| 2 | `* 专项简介` | 单行输入框，占位「请输入内容」 | §14.1 |
+| 3 | `* 国家地区` | 选择器（▾，空态占位） | §15.1 |
+| 4 | `* 涉及类别` | 行内「添加项」实心按钮组（见 §42.5） | §42.5 |
+| 5 | `* 显示指数` | 选择器（▾，占位「请选择」） | §15.1 |
+
+- label `14px Regular`，`#C5CFE0` (ZS-004-02)，右对齐；必填星号 `*` `#F5222D` (ZS-001-06) 置于 label 前（§21.4）
+- 表单项纵向间距 `--spacing-4` (16px)（§7.1）
+
+### 42.4 复合输入行（输入框 + 行内下拉 + 行内按钮）
+
+「专项名称」行把主输入框、「一键导入历史专项模板」下拉、「预览」主按钮拼在同一行。
+
+| 元素 | 色值 / 规格 | 来源 |
+|------|-------------|------|
+| 主输入框 | 沿用 §14.1，弹性撑满左侧剩余宽 | §14.1 |
+| 行内下拉「一键导入历史专项模板 ▾」 | 沿用 §15.1 选择器触发器，固定宽（约 `200px`），占位文字 `#6E88B0` | §15.1 |
+| 行内按钮「预览」 | §5.2.1 主按钮（实心 `#1677FF` + 白字） | §5.2.1 |
+| 元素间水平间距 | `--spacing-2` (8px) | §7.1 |
+| 三者垂直对齐 | 统一 `32px` 高，基线居中 | §5.1 |
+
+### 42.5 行内「添加项」实心按钮（+ 类别一 / + 类别二）
+
+「涉及类别」用一排实心主色蓝按钮，左侧 `+` 图标，点击进入对应类别的添加 / 编辑流程。
+
+| 状态 | 背景 | 文字 / 图标 | 来源 |
+|------|------|-------------|------|
+| 默认 | `#1677FF` (ZS-002-06) | `#FFFFFF` | §5.2.1 / §5.3.2 |
+| Hover | `#0958D9` (ZS-002-07) | `#FFFFFF` | §5.2.1 |
+| Active | `#003EB3` (ZS-002-08) | `#FFFFFF` | §5.2.1 |
+
+- 高度 `32px`，圆角 `2px`（§4.1），内边距 `0 14px`（§5.1）
+- `+` 图标与文字同色 `#FFFFFF`，间距 `--spacing-1` (4px)（§5.3.2）
+- 按钮之间间距 `--spacing-2` (8px)
+- 与 §21.5.1 分段按钮组的区别：分段组是**互斥单选**（选中才高亮）；此处每个按钮都是**独立的添加入口**，常驻主色实心。
+
+### 42.6 底部操作（沿用 §21.6）
+
+| 元素 | 规格 | 来源 |
+|------|------|------|
+| 对齐 | 居中（跟随截图） | §21.6 |
+| 「取消」 | §5.2.2 默认按钮（Outline） | §5.2.2 |
+| 「保存」 | §5.2.1 主按钮（实心蓝） | §5.2.1 |
+| 顺序 / 间距 | 取消在左、保存在右；间距 `--spacing-2` (8px) | §5.3.4 |
+
+### 42.7 CSS Token 参考
+
+```css
+:root {
+  /* 复合输入行 */
+  --field-row-gap:        8px;        /* --spacing-2 元素间距 */
+  --field-addon-select-w: 200px;      /* 行内下拉固定宽 */
+  --field-row-h:          32px;       /* 统一高度 */
+
+  /* 行内添加按钮（沿用主按钮） */
+  --addbtn-bg:            #1677FF;    /* ZS-002-06 */
+  --addbtn-bg-hover:      #0958D9;    /* ZS-002-07 */
+  --addbtn-bg-active:     #003EB3;    /* ZS-002-08 */
+  --addbtn-text:          #FFFFFF;
+}
+```
+
+---
+
+## 43. 卡片列表页（监测任务卡片）
+
+> 对应设计稿「监测任务卡片列表」（截图 ui-26）。这是 §22 卡片在「监测任务管理」场景下的整页范例：顶部导航沿用 §8、左侧三级菜单沿用 §8.3、卡片容器沿用 §22，本节补充**页面工具条**（搜索 + 添加 + 排序）与**监测任务卡片**的专用布局（头部 + 总量 KPI + 平台统计矩阵 + 底部操作 + 空态）。配色从 §1.1.3 渐蓝系（ZS-002，主色 / KPI 数字）与 §1.1.5 深蓝系（ZS-004，容器 / 文字）取。
+
+### 43.1 整体布局
+
+```
+┌─ Header（§8.2）──────────────────────────────────────────────┐
+├──┬────────────────────────────────────────────────────────────┤
+│三│ [🔍 搜索关键词/任务名称  ] [+ 添加任务]   排序: 创建时间▾ ↑升序 │  ← 工具条
+│级│ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌──────────┐ │
+│菜│ │ 莫某某 10247│ │ 冯某某 10247│ │ 钱某艺 10247│ │ 赵磊   12 │ │  ← 卡片网格
+│单│ │ 社交媒体(52)│ │ 社交媒体(52)│ │ 社交媒体(52)│ │  ...      │ │
+│  │ │ [开始监测] │ │ [开始监测] │ │ [开始监测] │ │           │ │
+│  │ └────────────┘ └────────────┘ └────────────┘ └──────────┘ │
+└──┴────────────────────────────────────────────────────────────┘
+```
+
+### 43.2 页面工具条
+
+| 元素 | 色值 / 规格 | 来源 |
+|------|-------------|------|
+| 搜索框 | 沿用 §14.2 基本搜索框，占位「搜索关键词 / 任务名称」 | §14.2 |
+| 「+ 添加任务」 | §5.3.2 图标 + 文字主按钮（实心 `#1677FF` + 白字 + `+`） | §5.3.2 |
+| 排序标签「排序」 | `14px Regular`，`#6E88B0` (ZS-004-04) | — |
+| 排序字段「创建时间 ▾」 | §15.1 选择器触发器（小号） | §15.1 |
+| 升 / 降序切换「↑ 升序 / ↓ 降序」 | §5.2.3 文本按钮，激活向 `#4096FF` (ZS-002-05) | §5.2.3 |
+| 工具条 → 卡片区间距 | `--spacing-5` (24px) | §7.1 |
+| 工具条内元素间距 | `--spacing-3` (12px) | §7.1 |
+
+### 43.3 监测任务卡片
+
+```
+┌──────────────────────────────────────┐
+│ 👤 莫某某                       10247  │  ← 头部：头像+名称 / 右上总量
+│    2023-09-09 09:13:00          总数量 │
+│ ────────────────────────────────────  │
+│ 社交媒体 (52)                          │  ← 统计区标题
+│ 微博  16    推特   8   facebook 16     │  ← 平台统计矩阵
+│ 抖音  12    土豆   6   大牛网    9     │
+│ ────────────────────────────────────  │
+│ url: t.djxqbjhgf9y.cn   也方开夫某利地址│
+│              [ 开始监测 ]              │  ← 底部操作
+└──────────────────────────────────────┘
+```
+
+#### 43.3.1 结构与配色
+
+| 元素 | 色值 / 规格 | 来源 |
+|------|-------------|------|
+| 卡片容器 | 同 §22.1（背景 `#122347` / 边框 `#1A2F5A` / 圆角 `4px` / 一级阴影） | §22.1 |
+| 头像占位 | 圆 `40px`，底 `#1A2F5A` (ZS-004-07)，图标 `#6E88B0` | §22.3 |
+| 任务名（莫某某） | `16px Medium`，`#FFFFFF` | §22.3 |
+| 创建时间 | `12px Regular`（D-DIN 数字），`#6E88B0` (ZS-004-04) | §8.2.5 |
+| 总量数值（10247） | `26px Bold`（D-DIN），`#4096FF` (ZS-002-05) | §2.1.2 / §1.1.3 |
+| 总量标签「总数量」 | `12px Regular`，`#6E88B0` (ZS-004-04) | — |
+| 头部底分割线 | `1px solid #1A2F5A` (ZS-004-07) | §6.1 |
+
+#### 43.3.2 平台统计矩阵
+
+统计区为「平台名 + 数值」多列网格（如 社交媒体 (52) 下的 微博 / 推特 / facebook…）。
+
+| 元素 | 色值 / 规格 | 来源 |
+|------|-------------|------|
+| 区标题「社交媒体 (52)」 | `14px Medium`，`#C5CFE0` (ZS-004-02)；括号计数 `#6E88B0` | — |
+| 平台名 | `14px Regular`，`#6E88B0` (ZS-004-04) | — |
+| 平台数值（数字） | `16px Bold`（D-DIN），`#C5CFE0` (ZS-004-02) | §2.1.2 |
+| 矩阵列数 | 3 列等分，行间距 `--spacing-2` (8px) | §7.1 |
+| 名 / 值间距 | `--spacing-1` (4px) | §7.1 |
+
+#### 43.3.3 底部操作
+
+| 元素 | 色值 / 规格 | 来源 |
+|------|-------------|------|
+| 「开始监测」 | §5.2.1 主按钮（实心 `#1677FF`）；运行中切 §5.4.2 加载态 | §5.2.1 / §5.4.2 |
+| 次要链接（如 url / 地址） | §5.2.3 文本按钮 `#4096FF` (ZS-002-05) | §5.2.3 |
+| 操作区上分割线 | `1px solid #2D4473`（弱化） | §6.1 |
+
+#### 43.3.4 空态卡片变体
+
+部分卡片暂无数据（总量 `0` + 占位）：
+
+| 元素 | 色值 / 规格 | 来源 |
+|------|-------------|------|
+| 总量数值 | `0`，`26px Bold`，`#6E88B0` (ZS-004-04，弱化非主色) | — |
+| 占位文字「暂无数据」 | `14px Regular`，`#6E88B0` (ZS-004-04)，居中 | §35.9 |
+| 占位插画 | 灰度线性图标，`#4A6491` (ZS-004-05) | §35.9 |
+
+### 43.4 卡片栅格（沿用 §22.4）
+
+| 规则 | 取值 | 来源 |
+|------|------|------|
+| 列数 | 自适应，常用 3~4 列 | — |
+| 卡片横 / 纵间距 | `--spacing-6` (32px) | §22.4 |
+| 卡片内边距 | `--spacing-4` (16px) | §22.4 |
+
+### 43.5 CSS Token 参考
+
+```css
+:root {
+  /* 监测任务卡片 */
+  --task-card-name:     #FFFFFF;
+  --task-card-time:     #6E88B0;   /* ZS-004-04 */
+  --task-kpi-num:       #4096FF;   /* ZS-002-05 总量数字 */
+  --task-kpi-label:     #6E88B0;   /* ZS-004-04 */
+  --task-stat-name:     #6E88B0;   /* ZS-004-04 平台名 */
+  --task-stat-num:      #C5CFE0;   /* ZS-004-02 平台数值 */
+  --task-divider:       #1A2F5A;   /* ZS-004-07 头部分割 */
+  --task-divider-weak:  #2D4473;   /* ZS-004-06 操作区分割 */
+  --task-empty-text:    #6E88B0;   /* ZS-004-04 空态 */
+}
+```
+
+---
+
+## 44. 数据概览仪表盘（KPI 指标条 + 综合图表）
+
+> 对应设计稿「资源使用率概览大屏」（截图 ui-27）。这是一张把 §35–§41 各图表与 §28 表格、§9.1 页签组合在一起的概览页。本节补充截图顶部出现而前文未单列的新原子——**KPI 指标卡条**（图标 + 标签 + 大数值 + 已用 + 迷你环 + 同比 / 环比箭头徽标），其余区块均引用既有章节。配色从 §1.1.3 渐蓝系（ZS-002，主色 / 数值）、§1.1.4 渐青系（ZS-003，辅色）、§1.1.5 深蓝系（ZS-004，容器 / 文字）取；涨跌语义色见 §44.2。
+
+### 44.1 整体布局
+
+```
+┌──┬────────────────────────────────────────────────────────────┐
+│三│ ▓ KPI 指标条（账号/设备/浏览器/代理IP/VPS/邮箱/手机卡/链卡服 使用率）▓│
+│级│ ┌─ ▌XXX标题 ───────────────┐ ┌─ ▌XXX标题（资源列表）────────┐│
+│菜│ │ [全部|账号资源|设备指标…]  │ │ 🔍搜索   排序                ││
+│单│ │  ◐异常率40%  ╱╲折线异常点 │ │ 资源资料  关联设备  2024-…   ││
+│  │ │  总量300 正常270 异常30   │ │ …（§28 表格行）              ││
+│  │ └───────────────────────────┘ └──────────────────────────────┘│
+│  │ ┌─ ▌XXX标题 ───────────────────────┐ ┌─ ▌XXX标题 ──────────┐│
+│  │ │ 异常分析 饼 + 折线（§37 / §39）    │ │ ◐300/270 + 趋势饼    ││
+│  │ └────────────────────────────────────┘ └─────────────────────┘│
+└──┴────────────────────────────────────────────────────────────┘
+```
+
+### 44.2 涨跌语义色
+
+| 语义 | 色值 | 来源 |
+|------|------|------|
+| 上升 / 正向（▲） | `#13C2C2` (ZS-003-06，辅色青) | §1.1.4 |
+| 下降 / 负向（▼） | `#F5222D` (ZS-001-06，主色红) | §1.1.2 |
+| 持平 | `#6E88B0` (ZS-004-04) | §1.1.5 |
+
+> 涨跌仅用语义色，不混入图表多系列色；正向用辅色青（ZS-003）而非主色蓝，避免与 KPI 数值蓝撞色。
+
+### 44.3 KPI 指标卡条
+
+横向一排等宽指标卡，每张承载一个使用率指标（如「账号使用率 139 已用」+ 迷你环 + 同比箭头）。
+
+```
+┌────────────────────────┐
+│ 🅰  账号使用率           │  ← 图标 + 标签
+│ 139       ◐ 45% ▲       │  ← 大数值 + 迷你环 + 同比
+│ 已用              同比   │
+└────────────────────────┘
+```
+
+| 元素 | 色值 / 规格 | 来源 |
+|------|-------------|------|
+| 卡片容器 | 背景 `#122347` (ZS-004-08)，边框 `1px solid #1A2F5A`，圆角 `4px`，一级阴影 | §22.1 |
+| 指标图标 | `20px`，主色 `#4096FF` (ZS-002-05) 单色化 | §1.1.6 |
+| 指标标签（账号使用率） | `14px Regular`，`#C5CFE0` (ZS-004-02) | — |
+| 大数值（139） | `26px Bold`（D-DIN），`#FFFFFF` | §2.1.2 |
+| 单位 / 说明「已用」 | `12px Regular`，`#6E88B0` (ZS-004-04) | — |
+| 迷你环（mini-donut） | 直径 `32px`，环宽 `4px`，已用段 `#1677FF` (ZS-002-06)，底环 `#2D4473` (ZS-004-06) | §39.2 |
+| 环内百分比 | `12px Bold`（D-DIN），`#FFFFFF` | §39.3 |
+| 同比 / 环比箭头徽标 | `12px`，▲ 用 `#13C2C2`、▼ 用 `#F5222D`（见 §44.2） | §44.2 |
+| 卡片宽度 | 等分横排（8 张则各占 1/8），最小宽 `160px` | — |
+| 卡片间距 | `--spacing-4` (16px) | §7.1 |
+| 卡片内边距 | `--spacing-4` (16px) | §7.1 |
+
+### 44.4 区块组合引用
+
+| 区块 | 复用 | 备注 |
+|------|------|------|
+| 区块标题（▌XXX标题） | §35.2 图表标题（主色蓝竖条 + 文字） | — |
+| 分类页签（全部 / 账号资源 / …） | §9.1.1 横向页签 | 激活 `#4096FF` + `2px` 下划线 |
+| 日期筛选（右上 `2023-02`） | §17.1 日期触发器 | — |
+| 异常率环形图（40% / 总量300 / 正常270 / 异常30） | §39 环形图 | 正常段主色蓝、异常段 `#F5222D`（§44.2） |
+| 折线异常点图（1月10日 异常率12.9%） | §37.3 单线异常点图 + §35.6 Tooltip | 异常点用红 `#F5222D` 强调 |
+| 资源列表表格 | §28 表格 + §14.2 搜索 + §13 分页 | — |
+| 异常分析饼 / 趋势饼 | §39 环形图 | 多系列回落 §41 色序 |
+| 容器 / 内边距 / 多图间距 | §35.1 图表容器 | `--spacing-5` / `--spacing-6` |
+
+### 44.5 交互
+
+| 行为 | 规则 |
+|------|------|
+| KPI 卡 hover | 卡片阴影升二级（§3.1.4），迷你环高亮，弹出 §35.6 Tooltip（已用 / 总量 / 同比明细） |
+| 页签切换 | 切换分类后下方图表与表格联动刷新（§9.1.1） |
+| 图表 hover | 沿用各图表节交互（§37.6 / §39.4 等） |
+| 日期筛选变更 | 重新拉取区块数据，图表入场动画重放 |
+
+### 44.6 CSS Token 参考
+
+```css
+:root {
+  /* KPI 指标卡 */
+  --kpi-card-bg:     #122347;   /* ZS-004-08 */
+  --kpi-card-border: #1A2F5A;   /* ZS-004-07 */
+  --kpi-icon:        #4096FF;   /* ZS-002-05 */
+  --kpi-label:       #C5CFE0;   /* ZS-004-02 */
+  --kpi-value:       #FFFFFF;
+  --kpi-sub:         #6E88B0;   /* ZS-004-04 已用 */
+  --kpi-ring-used:   #1677FF;   /* ZS-002-06 迷你环已用段 */
+  --kpi-ring-track:  #2D4473;   /* ZS-004-06 迷你环底 */
+
+  /* 涨跌语义 */
+  --trend-up:        #13C2C2;   /* ZS-003-06 上升（辅色青） */
+  --trend-down:      #F5222D;   /* ZS-001-06 下降（红） */
+  --trend-flat:      #6E88B0;   /* ZS-004-04 持平 */
+}
+```

frontend-web/docs/ui规范-深蓝/README.md

@@ -0,0 +1,82 @@
+# 深蓝色 UI 规范（拆分版）
+
+面向开发的深蓝主题设计规范。原单文件 `../ui修改-深蓝.md`（约 5200 行）已按模块拆分到本目录，便于按需查阅、减少 diff 冲突，也方便配合 AI 只加载相关分册。
+
+> **颜色唯一来源**：所有色值以 **§1 色彩**（见 [`00-基础-色彩字体间距.md`](./00-基础-色彩字体间距.md)）为准，可执行变量见 [`tokens.css`](./tokens.css)。业务代码 **import `tokens.css` 并用 `var(--token)`**，不要硬编码 HEX。
+
+## 分册
+
+| 文件 | 章节 | 内容 |
+|------|------|------|
+| [`00-基础-色彩字体间距.md`](./00-基础-色彩字体间距.md) | §1–§7 | 色彩 / 字体 / 阴影 / 圆角 / 按钮 / 分割线 / 间距 |
+| [`01-导航.md`](./01-导航.md) | §8–§13 | 导航组件 / 锚点页签 / 步骤条 / 面包屑 / 页头 / 分页 |
+| [`02-表单.md`](./02-表单.md) | §14–§21 | 输入框 / 选择器 / 单复选 / 日期 / 穿梭框 / 树选择 / 上传 / 弹窗 |
+| [`03-数据展示.md`](./03-数据展示.md) | §22–§34 | 卡片 / 折叠 / 描述列表 / 列表 / 时间轴 / 进度条 / 表格 / 标签 / 树 / 对话框 / 提示 / 气泡确认 |
+| [`04-图表.md`](./04-图表.md) | §35–§41 | 图表通用 / 柱状 / 折线 / 甘特 / 环形 / 关系散点 / 图表色值 |
+| [`05-页面范例.md`](./05-页面范例.md) | §42–§44 | 表单弹窗 / 卡片列表页 / 数据概览仪表盘 |
+| [`tokens.css`](./tokens.css) | — | 全量 CSS 变量（颜色 / 间距 / 圆角 / 阴影 / 字体），可直接 import |
+
+## § 索引（编号 → 所在文件）
+
+章节编号 `§N` 全局唯一、跨文件不变；文中 `§N` / `§N.x` 引用按下表定位。
+
+| § | 标题 | 文件 |
+|---|------|------|
+| §1 | 色彩 | 00 |
+| §2 | 字体 | 00 |
+| §3 | 阴影 | 00 |
+| §4 | 圆角 | 00 |
+| §5 | 按钮 | 00 |
+| §6 | 分割线 | 00 |
+| §7 | 间距 | 00 |
+| §8 | 导航组件 | 01 |
+| §9 | 锚点与页签 | 01 |
+| §10 | 步骤条 | 01 |
+| §11 | 面包屑 | 01 |
+| §12 | 页头 | 01 |
+| §13 | 分页 | 01 |
+| §14 | 输入框（搜索框） | 02 |
+| §15 | 选择器 | 02 |
+| §16 | 单选与多选 | 02 |
+| §17 | 日期选择器 | 02 |
+| §18 | 穿梭框 | 02 |
+| §19 | 树选择 | 02 |
+| §20 | 上传 | 02 |
+| §21 | 弹出式窗口（Modal） | 02 |
+| §22 | 卡片 | 03 |
+| §23 | 折叠面板 | 03 |
+| §24 | 描述列表 | 03 |
+| §25 | 列表 | 03 |
+| §26 | 时间轴（节点型） | 03 |
+| §27 | 进度条 | 03 |
+| §28 | 表格 | 03 |
+| §29 | 标签 | 03 |
+| §30 | 树形控件 | 03 |
+| §31 | 时间轴（长文本） | 03 |
+| §32 | 对话框（确认框） | 03 |
+| §33 | 全局提示 | 03 |
+| §34 | 气泡确认 | 03 |
+| §35 | 图表通用规范 | 04 |
+| §36 | 柱状图 | 04 |
+| §37 | 折线图 | 04 |
+| §38 | 甘特图 | 04 |
+| §39 | 环形图 | 04 |
+| §40 | 关系图 / 散点图 | 04 |
+| §41 | 图表色值 | 04 |
+| §42 | 表单弹窗范例 | 05 |
+| §43 | 卡片列表页 | 05 |
+| §44 | 数据概览仪表盘 | 05 |
+
+## 约定
+
+- **颜色**：以 §1 为准，代码用 `tokens.css` 的 `var(--token)`。功能语义色（成功/警告/错误/信息/处理中）见 §1.1.9 / `--func-*`。
+- **间距**：仅用 §7 的 8px 阶梯（`--spacing-1..8`），禁用 5px / 13px 等非阶梯值。
+- **圆角**：按钮/输入/标签 `2px`，卡片/分栏/弹窗 `4px`（`--radius-*`）。
+- **跨节引用**：保留 `§N` 编号，用上方「§ 索引」定位文件。
+- **名称易混点**：§26 时间轴(节点型) ↔ §31 时间轴(长文本)；§21 弹出式窗口(Modal) ↔ §32 对话框(确认框)。
+- **图表两套色板**：§1.1.8（高彩度，强调单值）与 §41（淡色系，多分类并列）并存，优先级见 §41.3。
+
+## 维护
+
+- 改色 / 改间距 → 先改 **`tokens.css` + §1/§7**，组件分册回落引用，不在分册里另立硬编码。
+- 新增整页范例 → 进 `05-页面范例.md`，沿用既有组件 § 与 `tokens.css`。

frontend-web/docs/ui规范-深蓝/tokens.css

@@ -0,0 +1,211 @@
+/* =============================================================================
+ * 深蓝色 UI 规范 · 设计令牌（tokens.css）
+ * -----------------------------------------------------------------------------
+ * 这是《深蓝色 UI 规范》全站颜色 / 间距 / 圆角 / 阴影 / 字体的唯一可执行来源。
+ * 开发时优先 import 本文件并使用 var(--token)，不要在业务代码里硬编码 HEX。
+ *
+ * 文档对应：
+ *   §1 色彩  → 原始色阶 --zs-*、功能语义 --func-*、装饰/图表色板
+ *   §2 字体  → --font-* / --fs-*
+ *   §3 阴影  → --shadow-*
+ *   §4 圆角  → --radius-*
+ *   §7 间距  → --spacing-*
+ * 组件级 token（--card-* / --modal-* / --kpi-* 等）保留在各分册的「CSS Token 参考」
+ * 小节中，均回落到本文件的原始/语义 token。
+ * ========================================================================== */
+
+:root {
+  /* ---------------------------------------------------------------------------
+   * 1. 原始色阶（§1.1.2–§1.1.5）—— 01 最浅 → 10 最深
+   * ------------------------------------------------------------------------ */
+
+  /* 渐红系 ZS-001 —— 警示 / 错误 / 强调 */
+  --zs-001-01: #FFF1F0;
+  --zs-001-02: #FFCCC7;
+  --zs-001-03: #FFA39E;
+  --zs-001-04: #FF7875;
+  --zs-001-05: #FF4D4F;
+  --zs-001-06: #F5222D;
+  --zs-001-07: #CF1322;
+  --zs-001-08: #A8071A;
+  --zs-001-09: #820014;
+  --zs-001-10: #5C0011;
+
+  /* 渐蓝系 ZS-002 —— 信息 / 链接 / 次级操作（含主色） */
+  --zs-002-01: #E6F4FF;
+  --zs-002-02: #BAE0FF;
+  --zs-002-03: #91CAFF;
+  --zs-002-04: #69B1FF;
+  --zs-002-05: #4096FF;
+  --zs-002-06: #1677FF;
+  --zs-002-07: #0958D9;
+  --zs-002-08: #003EB3;
+  --zs-002-09: #002C8C;
+  --zs-002-10: #001D6C;
+
+  /* 渐青系 ZS-003 —— 成功 / 在线 / 数据高亮（含辅色） */
+  --zs-003-01: #E6FFFB;
+  --zs-003-02: #B5F5EC;
+  --zs-003-03: #87E8DE;
+  --zs-003-04: #5CDBD3;
+  --zs-003-05: #36CFC9;
+  --zs-003-06: #13C2C2;
+  --zs-003-07: #08979C;
+  --zs-003-08: #006D75;
+  --zs-003-09: #00474F;
+  --zs-003-10: #002329;
+
+  /* 深蓝系 ZS-004 —— 背景 / 容器 / 导航 / 文字（主题核心） */
+  --zs-004-01: #E8EDF5;
+  --zs-004-02: #C5CFE0;
+  --zs-004-03: #9BADC8;
+  --zs-004-04: #6E88B0;
+  --zs-004-05: #4A6491;
+  --zs-004-06: #2D4473;
+  --zs-004-07: #1A2F5A;
+  --zs-004-08: #122347;
+  --zs-004-09: #0C1836;
+  --zs-004-10: #060E24;
+
+  /* ---------------------------------------------------------------------------
+   * 2. 功能角色色（§1.1.6）—— 从色阶提取的语义别名
+   * ------------------------------------------------------------------------ */
+  --color-primary:         var(--zs-002-06);  /* #1677FF 主操作 */
+  --color-primary-hover:   var(--zs-002-07);  /* #0958D9 */
+  --color-primary-active:  var(--zs-002-08);  /* #003EB3 */
+  --color-link:            var(--zs-002-05);  /* #4096FF 链接 / 文本按钮 */
+  --color-accent:          var(--zs-003-06);  /* #13C2C2 辅色 */
+
+  --color-text:            var(--zs-004-02);  /* #C5CFE0 正文字体 */
+  --color-text-secondary:  var(--zs-004-04);  /* #6E88B0 次级字体 */
+  --color-text-disabled:   var(--zs-004-05);  /* #4A6491 禁用字体 */
+  --color-text-strong:     #FFFFFF;           /* 标题 / 强调 */
+
+  --color-bg-page:         var(--zs-004-09);  /* #0C1836 页面背景 */
+  --color-bg-container:    var(--zs-004-07);  /* #1A2F5A 容器背景 */
+  --color-bg-card:         var(--zs-004-08);  /* #122347 卡片背景 */
+  --color-bg-deepest:      var(--zs-004-10);  /* #060E24 全局底色 */
+  --color-border:          var(--zs-004-07);  /* #1A2F5A 容器边框 */
+  --color-border-strong:   var(--zs-004-04);  /* #6E88B0 控件边框 */
+  --color-white:           #FFFFFF;
+
+  /* ---------------------------------------------------------------------------
+   * 3. 功能语义色（§1.1.9）—— 成功/警告/错误/信息/处理中
+   *    成功绿、警告橙为标准色系外补充色；其余复用色阶。
+   * ------------------------------------------------------------------------ */
+  --func-success:          #52C41A;           /* 补充色 · 成功绿 */
+  --func-warning:          #FAAD14;           /* 补充色 · 警告橙 */
+  --func-error:            var(--zs-001-06);  /* #F5222D */
+  --func-info:             var(--zs-002-06);  /* #1677FF */
+  --func-processing:       var(--zs-003-06);  /* #13C2C2 */
+
+  /* 浅底变体（Message / Alert / Tag 背景，16% 透明度） */
+  --func-success-bg:       rgba(82, 196, 26, 0.16);
+  --func-warning-bg:       rgba(250, 173, 20, 0.16);
+  --func-error-bg:         rgba(245, 34, 45, 0.16);
+  --func-info-bg:          rgba(22, 119, 255, 0.16);
+
+  /* ---------------------------------------------------------------------------
+   * 4. 小面积装饰色（§1.1.7）—— 仅点缀 / 徽标，勿做大面积背景
+   * ------------------------------------------------------------------------ */
+  --deco-violet:           #6388FF;
+  --deco-danger:           #F5222D;
+  --deco-brand-blue:       #12306C;
+  --deco-teal:             #478880;
+  --deco-alert:            #950404;
+
+  /* ---------------------------------------------------------------------------
+   * 5. 字体（§2）
+   * ------------------------------------------------------------------------ */
+  --font-zh:     'Noto Sans S Chinese', 'Noto Sans SC', system-ui, sans-serif;
+  --font-num:    'D-DIN', 'Noto Sans S Chinese', sans-serif;   /* 数据数字 */
+  --font-digital:'DS-Digital', 'D-DIN', sans-serif;            /* 大屏特殊数字 */
+  --font-logo:   'DOUYUFont', 'Noto Sans S Chinese', sans-serif;
+  --font-table:  'Arial', 'Noto Sans S Chinese', sans-serif;   /* 表格数字 */
+
+  /* 常用字号（后台系统，§2.1.2） */
+  --fs-12: 12px;
+  --fs-14: 14px;
+  --fs-16: 16px;
+  --fs-18: 18px;
+  --fs-20: 20px;
+  --fs-24: 24px;
+  --fs-26: 26px;
+
+  /* ---------------------------------------------------------------------------
+   * 6. 间距（§7）—— 8px 基准，密(≤16) / 疏(≥24)，禁用非阶梯值
+   * ------------------------------------------------------------------------ */
+  --spacing-1: 4px;
+  --spacing-2: 8px;
+  --spacing-3: 12px;
+  --spacing-4: 16px;
+  --spacing-5: 24px;
+  --spacing-6: 32px;
+  --spacing-7: 40px;
+  --spacing-8: 56px;
+
+  /* ---------------------------------------------------------------------------
+   * 7. 圆角（§4）
+   * ------------------------------------------------------------------------ */
+  --radius-button: 2px;
+  --radius-input:  2px;
+  --radius-tag:    2px;
+  --radius-card:   4px;
+  --radius-panel:  4px;
+  --radius-modal:  4px;
+
+  /* ---------------------------------------------------------------------------
+   * 8. 阴影（§3.1.4）
+   * ------------------------------------------------------------------------ */
+  --shadow-1: 0 2px 8px rgba(22, 119, 255, 0.12);   /* 卡片悬浮 */
+  --shadow-2: 0 4px 16px rgba(22, 119, 255, 0.24);  /* hover / 弹出层 */
+  --shadow-3: 0 8px 32px rgba(6, 14, 36, 0.6);      /* Dialog / Drawer */
+  --shadow-modal-mask: rgba(6, 14, 36, 0.6);        /* 遮罩 */
+
+  /* 常用渐变 */
+  --gradient-header: linear-gradient(180deg, #122347 0%, #0C1836 100%);          /* 顶栏 §8.2.1 */
+  --gradient-title-line: linear-gradient(90deg, transparent 0%, #1677FF 50%, transparent 100%); /* 标题发光线 §8.2.4 */
+}
+
+/* =============================================================================
+ * 图表多系列色板
+ * ========================================================================== */
+:root {
+  /* 通用图表色序（§1.1.8，面积大：柱/折线/饼，高彩度） */
+  --chart-g-1: #1677FF;
+  --chart-g-2: #13C2C2;
+  --chart-g-3: #4096FF;
+  --chart-g-4: #36CFC9;
+  --chart-g-5: #69B1FF;
+  --chart-g-6: #5CDBD3;
+  --chart-g-7: #91CAFF;
+  --chart-g-8: #87E8DE;
+
+  /* 小面积图表色序（§1.1.8，散点/迷你图/徽标） */
+  --chart-s-1: #4096FF;
+  --chart-s-2: #36CFC9;
+  --chart-s-3: #FF4D4F;
+  --chart-s-4: #FFA39E;
+  --chart-s-5: #6388FF;
+  --chart-s-6: #478880;
+
+  /* 多系列填充色板（§41，淡色系，分类并列默认色序） */
+  --chart-p-red:       #FA9196;
+  --chart-p-redorange: #FCA58F;
+  --chart-p-orange:    #FDB887;
+  --chart-p-amber:     #FFCC80;
+  --chart-p-olive:     #DCD69A;
+  --chart-p-green:     #BAE1B3;
+  --chart-p-teal:      #97EBCD;
+  --chart-p-cyan:      #9EE4EA;
+  --chart-p-skyblue:   #A2E1F9;
+  --chart-p-blue:      #80BCFF;
+}
+
+/*
+ * 图表配色优先级（§41.3）：
+ *   有语义 → 用 --func-*；多分类并列 → 用 --chart-p-*（§41 色板）；
+ *   需强调单值 → 用 --chart-g-* / --chart-s-*（§1.1.8 高彩度）。
+ *
+ * 接入 ECharts 时按系列数取 option.color，见 §41.4 的 CHART_PALETTES。
+ */

frontend-web/docs/xvqiu-0616.md

@@ -0,0 +1,161 @@
+# 需求文档 · 问答中心左侧栏改造（0616）
+
+> 整理自 2026-06-16 需求草稿。本批需求统一围绕「问答中心」菜单下 5 个页面入口的**左侧侧边栏**进行改造，目标是让每个业务页面的左栏从「通用导航」变为「贴合该业务场景的快捷入口 + 历史记录」。
+>
+> 菜单结构参考：`frontend-web/src/core/page-layout/sidebar-menu.ts` 中 `qa-center`（问答中心）分组，含 5 个子项，正好对应下文 5 条需求。
+
+## 0. 背景与共性约定
+
+| 需求 | 菜单项 | id | 现有路由 | 对应页面/组件 |
+|------|--------|----|----------|--------------|
+| 1 | 通用问答 | `general-qa` | `/page/workspace/chats/new` | Workspace Chat + 左栏（`recent-chat-list.tsx` 等） |
+| 2 | 多智能体会商 | `multi-agent-roundtable` | `/page/strategy/qa/multi-agent-roundtable` | `roundtable-planning/pages/RoundtablePlanningPage.tsx` |
+| 3 | zzJC支持 | `qa-zzjc` | `/page/strategy/agents/6bf/chats/new` | `pages/AgentChatPage.tsx` |
+| 4 | zzXD应用 | `qa-zzxd` | `/page/strategy/agents/10d69686718349688e58a8790cb61024/chats/new` | `pages/AgentChatPage.tsx` |
+| 5 | 课题研究 | `qa-research` | `/page/canvas/ai-writing` | `open-canvas/pages/AIWritingPage.tsx` |
+
+**共性约定（适用于全部 5 条，除非单条另有说明）：**
+
+- 「更多」一律为可点击入口；点击后跳转到对应的完整列表/管理页（具体目标见各条「待确认」）。
+- 列表为空时的兜底：参考各条「现状」中的级联/空态规则；无内容时该区块整体隐藏或显示占位文案（待 UI 设计确认，默认隐藏，与现有 `recent-chat-list.tsx` 一致）。
+- 左栏宽度、折叠交互沿用现有侧边栏体系（`SidebarGroup` 系列组件）。
+- 所有「智能体」相关数据复用 `core/agents`（`Agent` 类型已含 `is_pinned` / `is_favorite` / `featured_order`，scope 支持 `mine` / `square` / `builtin`）。
+
+---
+
+## 1. 通用问答 — 左侧栏改造
+
+**页面**：`/page/workspace/chats/new`
+
+### 1.1 现状
+当前左栏主要展示「最近会话」列表（`recent-chat-list.tsx`，已过滤 `scheduler` / `bootstrap` / `roundtable` 类型线程，置顶会话优先）。
+
+### 1.2 目标布局（自上而下）
+左栏从上到下依次为三块：**新建回答按钮 → 常用智能体 → 聊天记录**。
+
+#### ① 顶部：新建回答
+- 左栏最顶部放置「**新建回答**」按钮（主操作）。
+- 点击 = 开启一次全新的通用问答会话（等价于跳转 `/page/workspace/chats/new`）。
+
+#### ② 常用智能体（最多 3 个 + 更多）
+- 展示「常用智能体」卡片/列表项，**最多 3 个**。
+- 数据来源采用**级联兜底**逻辑（取到即用，不足再降级）：
+  1. 若用户有**置顶智能体**（`is_pinned = true`）→ 展示置顶的；
+  2. 否则展示**用户自己的智能体**（`scope = "mine"`）；
+  3. 仍没有 → 展示**默认广场智能体**（`scope = "square"` / `builtin`，即广场默认推荐）。
+- 三者按上述优先级取，最终最多取 3 个。
+- 下方显示「**更多**」入口。
+- 点击某个常用智能体 → 进入该智能体的对话（待确认：是否为该智能体新建会话）。
+
+#### ③ 聊天记录（最多 10 条 + 更多）
+- 展示用户的问答聊天记录，**最多 10 条**（沿用现有 `useThreads` + 过滤规则）。
+- 下方显示「**更多**」入口。
+- 点击「更多」→ **跳转到问答记录页面**（完整聊天记录列表页）。
+
+### 1.3
+- 「常用智能体」点击后「打开该智能体主页」
+- 「常用智能体」的「更多」跳转目标页 智能体管理 `/page/strategy/agents`。
+- 「聊天记录」的「问答记录页面」具体路由http://localhost:5173/#/page/workspace/chats。
+- 级联兜底是（置顶组够 3 个就完全不展示我的/广场）如果不够「补足到 3 个
+
+---
+
+## 2. 多智能体会商 — 左侧栏重做
+
+**页面**：`/page/strategy/qa/multi-agent-roundtable`（`RoundtablePlanningPage`）
+
+### 2.1 现状
+圆桌会商页已有业务链选择、分析草稿等能力（`roundtable-planning/api/chains.ts`、`hooks/useRoundtableDrafts.ts`）。需求要求**左栏整体重做**。
+
+### 2.2 目标布局（自上而下）
+
+#### ① 顶部：业务链（公共，前 3 个）
+- 顶部展示**业务链**，仅取**公共**链条（`listChains("public")`，即所有已发布 `is_public = true` 的链条）。
+- 仅展示**前 3 个**。
+- 点击某条业务链 → 以该业务链启动一次会商（沿用现有"会商自动串联圆桌"流程，见记忆 `business-chain-mapping`）。
+
+#### ② 下方：分析记录
+- 业务链下方展示「**分析记录**」列表。
+- 数据来源：圆桌分析草稿/历史（`useRoundtableDrafts` / `listDrafts`）。
+- 点击某条分析记录 → 打开对应的历史会商分析。
+
+### 2.3 待确认
+- 「业务链」是否需要「更多」入口跳转到业务链条配置页（`/page/strategy/business-chains`）？需求未提及，默认仅展示前 3 个、无更多。  需要更多入口
+- 「分析记录」是否需要分页/「更多」？需求未提及，默认展示全部或合理上限 分析记录默认全部吧。
+- 公共业务链「前 3 个」的排序口径（创建时间倒序？已有 `listChains` 默认 newest first） 按照现在默认的显示来吧，然后要支持用户单选，如果用户选择后，点击进入多智能体研讨按钮时，直接按照选择的业务链进去执行，如果用户取消勾选，或没有勾选就还是打开弹窗。
+
+---
+
+## 3. zzJC支持 — 左侧栏改造（按类型聚合智能体）
+
+**页面**：`/page/strategy/agents/6bf/chats/new`（当前为单一智能体 `6bf` 的对话页）
+
+### 3.1 现状
+当前 zzJC支持直接进入某个固定智能体（id=`6bf`）的对话页（`AgentChatPage`）。
+
+### 3.2 目标布局
+- **左栏按「类型」分组**，展示该类型下的智能体列表（"类型"待确认，推测为智能体 `tags` / 分类）。
+- 智能体分组**下方**展示**聊天记录**。
+- 左栏**宽度与通用问答（需求 1）保持一致**（"左侧是问答宽"）。
+
+### 3.3 Admin 设置入口
+- 在 **admin 账号权限下**，页面**右侧顶部显示「设置」图标按钮**（齿轮图标）。
+- 点击设置按钮 → 打开设置面板，可对该模块进行配置。
+- 非 admin 账号不显示设置按钮（沿用 `sidebar-menu.ts` 中 `adminOnly` 同款角色判断）。
+
+### 3.4 待确认
+- 「类型」的确切含义：是智能体的 `tags`，还是 zzJC 业务自定义的一组分类？
+- 现 zzJC 入口是单个智能体 `6bf`；改为「按类型展示多个智能体」后，**进入该菜单时默认落地页是什么**（智能体列表？还是仍默认进 `6bf` 对话）？是否需要新建一个 zzJC 聚合页。
+- Admin「设置」具体可配置项：配置「该模块纳入哪些类型/哪些智能体」？还是其他（如默认智能体、欢迎语）？需明确设置项清单。
+- 「聊天记录」过滤范围：仅 zzJC 相关会话，还是全部会话？
+
+---
+
+## 4. zzXD应用 — 左侧栏改造
+
+**页面**：`/page/strategy/agents/10d69686718349688e58a8790cb61024/chats/new`
+
+### 4.1 需求
+**与需求 3（zzJC支持）完全一致**：
+- 左栏按类型展示该类型下的智能体 + 下方聊天记录；
+- 左栏宽度同通用问答；
+- admin 账号下右侧顶部显示设置图标按钮，可设置。
+
+### 4.2 待确认
+- 同需求 3 全部待确认项。
+- zzXD 与 zzJC 是否共用同一套「按类型 + 设置」组件（仅数据源/默认智能体不同），还是各自独立配置？建议**抽象为同一可复用组件**，通过参数区分。
+
+---
+
+## 5. 课题研究 — 左侧栏改造（研究模板 + 笔记本）
+
+**页面**：`/page/canvas/ai-writing`（`AIWritingPage`）
+
+### 5.1 目标布局（自上而下）
+
+#### ① 上半部分：研究模板
+- 左栏上半部分展示「**研究模板**」。
+- 研究模板 = **原来的「文章类型」**（`open-canvas/hooks/useArticleTypes.ts` 的 `articleTypes`，即 AI 写作表单里的「文章类型」选择项）。
+- 点击某个研究模板 → 以该模板/文章类型发起课题研究（沿用现有 `articleType` 设置逻辑）。
+
+#### ② 下半部分：笔记本
+- 左栏下半部分展示「**笔记本**」。
+- 笔记本内容 = **「简洁模式」左侧菜单下方展示的笔记本内容**（`useStudioNotebooks`，即 `workspace-nav-studio.tsx` 中渲染的 studio notebooks 列表）。
+- 点击某个笔记本 → 打开该笔记本（沿用现有 `/page/workspace/studio/notebooks/{id}` 行为，或作为课题研究的素材来源 `materialSource = 'notebook'`，待确认）。
+
+> 备注：草稿原文写作「简介模式」，结合代码应为「**简洁模式**」（`appearance-settings-page.tsx` 中的全局界面模式：全量 / 简洁；简洁模式下笔记本在左栏菜单展示）。
+
+### 5.2 待确认
+- 「研究模板」点击行为：仅预填表单 `articleType`，还是直接开始生成？
+- 「笔记本」点击行为：跳转笔记本详情页，还是将笔记本设为当前课题研究的素材来源（`materialSource='notebook'`）？
+- 上/下两部分是否各自可折叠、是否需要「更多」入口与数量上限？需求未提及。
+
+---
+
+## 6. 整体待确认与建议
+
+1. **复用性**：需求 3 / 4（zzJC / zzXD）布局完全相同，建议实现为同一套「按类型分组 + 聊天记录 + admin 设置」可复用组件，通过配置区分模块。
+2. **左栏宽度统一**：需求 1 / 3 / 4 都要求"问答宽"，建议统一左栏宽度常量，避免各页面各写一套。
+3. **「更多」目标页**：需求 1 涉及「智能体更多」「聊天记录更多→问答记录页」两个跳转目标需先确定路由是否已存在。
+4. **Admin 设置项清单**：需求 3 / 4 的设置面板具体能配置什么，需要产品给出字段清单后才能落地。
+5. **入口语义变更**：需求 3 / 4 把原「单一智能体对话」入口改为「按类型聚合」，菜单 `path` 与默认落地页可能需要调整，需同步确认。

frontend-web/docs/上游升级对比与建议.md

@@ -0,0 +1,156 @@
+# DeerFlow 上游升级对比与回合建议
+
+> 对比对象：`bytedance/deer-flow`（上游，HEAD `9f3be2a` @ 2026-05-30）vs 本仓库 fork。
+> 生成日期：2026-05-31。
+> 说明：按用户要求，**多语言 (i18n)** 与 **播客 / TTS (podcast)** 不在本次升级范围内，已剔除。
+
+---
+
+## 0. 背景与对比结论
+
+| 项 | 结论 |
+|---|---|
+| fork 切出时间 | **≈ 2026-05-12**（与目录名 `offline-backend-20260512` 吻合） |
+| 上游当前 HEAD | `9f3be2a` @ 2026-05-30，完整历史 2186 提交 |
+| fork 之后上游新增 | **95 个提交**（7 feat / 1 perf / 60 fix / 依赖与文档若干） |
+| 后端核心框架 `packages/harness/deerflow/` | **高度同源、目录结构完全一致**，差异主要来自这 95 个提交 |
+| 前端 | 技术栈已分道扬镳：上游仍是 **Next.js**，本仓库已迁到 **Vite + React Router**，文件几乎全不同 |
+
+「升级」分两类，本文都覆盖：
+- **A 类**：fork 之后上游真正新增的（95 提交）——同源、可 cherry-pick，**优先回合**。
+- **B 类**：fork 时就裁掉/换了路线、上游一直保留的能力——成本高、按业务取舍。
+
+---
+
+## 1. 后端升级（A 类：fork 后上游新增）
+
+### 1.1 新能力（feat / perf）
+
+| 日期 | 升级 | 提交 | 说明 |
+|---|---|---|---|
+| 05-29 | ToolOutputBudgetMiddleware | #3303 | 给超大工具输出做预算保护，防止单个结果撑爆上下文 |
+| 05-28 | MiMo reasoning 支持 | #3298 | 兼容小米 MiMo 模型思维链回传 |
+| 05-21 | 链路追踪命名优化 | #3101 | 图名改 `lead_agent`、用自定义 agent 名作 run_name |
+| 05-21 | 循环检测延迟告警 | #2752 | 警告延迟注入，减少对正常多轮对话的误打断 |
+| 05-20 | Sandbox 下载文件接口 | #3038 | 可把沙箱内产物取回 |
+| 05-15 | Discord 渠道增强 | #2842 | 仅@提及、thread 路由、typing 指示 |
+| 05-13 | 子代理 token 用量流式上报 | #2882 | subagent 消耗实时汇总到 header，利于展示/计费 |
+| 05-12 | perf：线程元数据过滤下推 SQL | #2865 | 线程列表筛选走 SQL，性能提升 |
+
+能力性增强（fix 前缀实为增强）：MCP 跨调用持久化会话、支持有状态 server（#3089 / #3203）；摘要触发阈值调优（#3174）。
+
+### 1.2 重要稳定性修复
+
+| 主题 | 提交 | 价值 |
+|---|---|---|
+| 摘要压缩后保留消息 | #3280 | 数据正确性关键 |
+| 重启后从持久化恢复 runs / interrupted 状态 | #2932(破坏性)、#2989、#3152、#3155 | 网关重启不丢运行 |
+| JWT secret 持久化、多 worker 共享网关 token | #2933、#3184 | 重启/多进程登录态不失效 |
+| memory 更新按 agent 隔离 + 包裹 JSON 解析健壮性 | #2941、#3252 | 记忆串号/解析修复 |
+| MCP 配置接口脱敏 | #2667 | 防密钥泄露 |
+| 阻塞 IO 移出事件循环 | #3311、#2822（+检测门禁 #3229） | 消除事件循环阻塞 |
+
+### 1.3 依赖升级
+- Python：`langsmith 0.7.36 → 0.8.0`、`idna 3.13 → 3.15`
+
+### 1.4 怎么做（回合 A 类后端升级）
+
+> 前提：本仓库 `packages/harness/deerflow/` 与上游高度同源，cherry-pick 冲突面小。
+
+1. **加上游为远程并拉取历史**（在后端所在 git 仓库根执行）：
+   ```bash
+   git remote add upstream https://github.com/bytedance/deer-flow.git
+   git fetch upstream
+   ```
+2. **逐条预览某个提交的改动范围**：
+   ```bash
+   git show <commit_hash> --stat
+   git show <commit_hash> -- backend/packages/harness/deerflow/...
+   ```
+3. **单条回合**（推荐用 `-x` 记录来源；如路径前缀不一致需先确认）：
+   ```bash
+   git cherry-pick -x <commit_hash>
+   # 冲突时：解决后
+   git cherry-pick --continue
+   ```
+   > 注意：上游后端在 `backend/` 子目录，本仓库后端在 `offline-backend-20260512/backend/`。若 cherry-pick 因路径不匹配失败，改用按文件打补丁：
+   > ```bash
+   > git show <hash> -- backend/<path> | git apply --directory=offline-backend-20260512/backend -p2 -3
+   > ```
+4. **回合后必跑校验**（在 `offline-backend-20260512/backend/`）：
+   ```bash
+   make test     # PYTHONPATH=. uv run pytest tests/ -v
+   make lint
+   ```
+   重点确认 `tests/test_harness_boundary.py`（harness→app 防火墙）与中间件链顺序未被破坏。
+5. **依赖升级**：同步上游 `pyproject.toml` 对应行后执行 `uv lock && make install`；离线环境需同步更新 `requirements-offline.txt` / `wheelhouse`。
+
+---
+
+## 2. 前端升级（B 类：上游有、本仓库缺）
+
+> 已剔除多语言、播客。下表为关键词核验结果（本仓库 vs 上游命中文件数）。
+
+| 功能 | 本仓库 | 上游 | 状态 |
+|---|---|---|---|
+| Prose 文本润色 | 0 | 8 | 上游独有 |
+| Replay 研究回放 | 2 | 29 | 上游完整，本仓库近乎无 |
+| PPT / PPTX 生成 | 2 | 14 | 上游完整，本仓库近乎无 |
+| Landing 落地页 | 0 | 11 | 上游独有（营销/介绍页，按需） |
+| 静态 demo 模式 | 无 | #3170 | fork 后上游新增 |
+
+前端体验类修复（可参考实现）：流式渲染、消息去重、历史消息 Mermaid 预览、新建会话即时入侧栏。
+前端依赖升级：`brace-expansion 1.x → 5.0.5`（安全）、`uuid 10 → 14`。
+
+### 2.1 怎么做（前端能力移植）
+
+> 前端技术栈已不同（Next.js → Vite + React Router），**不能直接 cherry-pick**，需按"读上游实现 → 适配到本仓库"的方式重写。
+
+通用步骤：
+1. 在上游 `frontend/src/` 定位目标功能的页面/组件/hook 与对应的后端 API 调用。
+2. 后端能力是否具备：Prose / PPT / Replay 依赖后端相应接口，先确认本仓库后端有无对应路由（多为 deep_research/skills 相关），**没有则前端无法独立完成**，需连带回合后端。
+3. 适配差异点：
+   - 路由：上游 app router (`src/app/...`) → 本仓库 `src/pages/` + `PageRoutes.tsx` / `WorkspaceRoutes.tsx`。
+   - 导航 API：用本仓库 `src/shims/`（`next/link`、`next/navigation` 已 polyfill）。
+   - 数据流：沿用本仓库 TanStack Query + `@langchain/langgraph-sdk` 流式。
+4. 验证：`pnpm typecheck` + `pnpm dev` 实测。
+
+---
+
+## 3. 推荐升级清单（按优先级）
+
+### P0 — 强烈建议（低风险、高价值，A 类）
+- **摘要压缩后保留消息 #3280** —— 数据正确性，直接影响长对话可用性。
+- **重启后恢复 runs / interrupted #2932 #2989 #3152 #3155** —— 生产稳定性核心。
+- **JWT secret 持久化 / 多 worker 共享 token #2933 #3184** —— 否则重启或多进程部署会掉登录态。
+- **阻塞 IO 移出事件循环 #3311 #2822** —— 并发吞吐与响应延迟改善。
+
+### P1 — 建议（实用增强）
+- **ToolOutputBudgetMiddleware #3303** —— 防超大工具输出拖垮上下文，对 agent 稳定性有实际帮助。
+- **MCP 持久化会话 / 有状态 server #3089 #3203** —— 若用到有状态 MCP server 则必需。
+- **MCP 配置接口脱敏 #2667** —— 安全加固。
+- **子代理 token 用量流式上报 #2882** —— 计费/可观测。
+- **线程元数据过滤下推 SQL #2865（perf）** —— 列表性能。
+
+### P2 — 按需（看是否用到对应模型/渠道）
+- MiMo reasoning #3298（用小米模型才需要）
+- Discord 渠道增强 #2842（用 Discord 才需要）
+- Sandbox 下载文件接口 #3038、追踪命名 #3101、循环检测延迟告警 #2752
+
+### 前端（按业务价值）
+- **Replay 研究回放** —— 对"深研/写作"类产品体验提升明显，建议优先（需后端配合）。
+- **Prose 文本润色** —— 与写作工作台契合，建议评估接入。
+- **PPT 生成** —— 若有汇报/导出诉求再做。
+- **Landing 落地页** —— 仅当面向外部用户时考虑。
+
+### 暂不做
+- 多语言 i18n（本次明确排除）
+- 播客 / TTS（本次明确排除）
+
+---
+
+## 4. 建议执行节奏
+1. 先做 **P0 后端 4 项** + 跑全量测试，单独提交一个"上游稳定性回合"分支。
+2. 再做 **P1**，逐条 cherry-pick、逐条验证。
+3. 前端 **Replay / Prose** 立项评估（确认后端依赖），单独排期重写适配。
+4. 依赖升级随回合同步，离线包 (`wheelhouse` / `requirements-offline.txt`) 一并更新。