Merge branch 'master' of http://192.168.0.200/knowledge-base-bj/deerflow-server into gzy

CLAUDE.md

@@ -82,11 +82,13 @@ The frontend (`frontend-web/`) is a React 19 + Vite SPA:
 - **轻应用中心 (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).
 - **敏感词管理 (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.
+- **按钮管理 (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 (resolved via `/api/business-mapping`, opening message in `sessionStorage.pendingAgentMessage`); the `-A` suffix (`3qfx-A`/…) → **multi-agent roundtable** with `roundtablePrefill.businessCode` so the page auto-selects the configured 业务链条. 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) **per-task draft isolation** — drafts save/list/restore by `task_id` (one taskId = many records, shared across users; backend `GET /api/roundtable-drafts/by-task/{id}` + `/latest`); 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/:thread_id}` 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. The agent chat is rendered via `TaskEmbeddedAgentChat`, which passes `AgentChatPage`'s `chatBasePath` prop so the post-send URL rewrite + new-chat button stay in the task-management context (instead of the standalone `/agents/...` route). Any failure (no consumer URL / fetch error / unmapped goPath / no configured agent) silently falls back to the default home. Helpers: `core/auth/task-deeplink.ts`.
+- **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). 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)` — filtered by **both** `metadata.taskId` AND `metadata.agent_id` so the three businesses' conversations stay isolated even though they share one taskId) + 新建对话; the `…/chats` index (`TaskFxIndexResolver`) opens the latest task thread or 新建. The right `:thread_id` host differs by business: **rwfx** → `TaskFxChat` (`AgentChatPage taskGate`) = full workspace (non-`lite`): 目的树闸门 panel + 清除记录 (placed under 新建对话); **xdfx** → also `TaskFxChat` (same 目的树闸门 query+display, same `purpose_detail_url`) but workspace passed `lite`; **3qfx** → `TaskBindChat` (`AgentChatPage taskBind`, `lite`) = 1:N list only, no gate, and 新建对话 **auto-sends** the task opening text (`taskAutoSendText`; gate Line 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
 

frontend-web/.env.development

@@ -7,6 +7,12 @@ 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

frontend-web/.env.network

@@ -7,6 +7,12 @@ 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://47.88.25.99:7001
 VITE_LANGGRAPH_BASE_URL=http://47.88.25.99:7001/api

frontend-web/.env.production

@@ -5,7 +5,10 @@
 VITE_USE_REAL_DATA=true
 
 # 任务详情（登录深链 cop-task-detail）数据源：默认真实接口；改成 true 走本地假数据（调试用）。
-VITE_MOCK_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

frontend-web/.env.sit

@@ -7,6 +7,12 @@ 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

frontend-web/src/App.tsx

@@ -1,4 +1,4 @@
-import { useMemo } from "react";
+import { useEffect, useMemo } from "react";
 import { Navigate, Route, Routes } from "react-router-dom";
 import { ThemeProvider as NextThemesProvider } from "next-themes";
 
@@ -17,6 +17,10 @@ import {
 } from "@/core/embed/params";
 import { usePublicEmbedTheme } from "@/core/embed/background";
 import { readWujieProps } from "@/core/embed/wujie";
+import {
+  resolveForcedEmbedTheme,
+  syncEmbedSessionFromSearch,
+} from "@/core/embed/embed-session";
 
 import { HashRouter, useLocation } from "react-router-dom";
 
@@ -41,7 +45,16 @@ function AppProviders({ children }: { children: React.ReactNode }) {
   const locale = useMemo(() => detectLocale(), []);
   const location = useLocation();
   const publicEmbedTheme = usePublicEmbedTheme();
+  // iframe 嵌入会话（按标签页 sessionStorage）集中在此同步：任何带 `&embed=1` 的入口（深链登录页
+  // 或直接深链路由）一进来就启用、`embed=0` 关闭，后续干净路由靠会话维持去 chrome + 强制主题。
+  useEffect(() => {
+    syncEmbedSessionFromSearch(location.search);
+  }, [location.search]);
   const forcedTheme = useMemo(() => {
+    // iframe 嵌入模式（外部系统 `&embed=1`）最高优先：按本标签页的嵌入主题强制明/暗。
+    // 走 next-themes forcedTheme（不写 localStorage）→ 同浏览器另开的正常系统页不受影响。
+    const embedTheme = resolveForcedEmbedTheme(location.search);
+    if (embedTheme) return embedTheme;
     const routeTheme = resolveForcedThemeForPath(location.pathname);
     if (routeTheme) return routeTheme;
     if (location.pathname === "/embed/roundtable") {

frontend-web/src/components/page-sidebar.tsx

@@ -8,6 +8,7 @@ import {
   Folder,
   FolderOpen,
   ListTree,
+  MousePointerClick,
   Settings,
   ShieldAlert,
   User,
@@ -213,6 +214,14 @@ function SecondaryNavSidebar() {
                       菜单管理
                     </DropdownMenuItem>
                   )}
+                  {isAdmin && (
+                    <DropdownMenuItem
+                      onClick={() => navigate("/page/strategy/admin/task-buttons")}
+                    >
+                      <MousePointerClick className="size-4" />
+                      按钮管理
+                    </DropdownMenuItem>
+                  )}
                   {canManageSensitiveWords() && (
                     <DropdownMenuItem
                       onClick={() => navigate("/page/strategy/admin/sensitive-words")}
@@ -493,6 +502,12 @@ function LegacyAccordionSidebar({
                   菜单管理
                 </DropdownMenuItem>
               )}
+              {isAdmin && (
+                <DropdownMenuItem onClick={() => navigate("/page/strategy/admin/task-buttons")}>
+                  <MousePointerClick className="size-4" />
+                  按钮管理
+                </DropdownMenuItem>
+              )}
               {canManageSensitiveWords() && (
                 <DropdownMenuItem onClick={() => navigate("/page/strategy/admin/sensitive-words")}>
                   <ShieldAlert className="size-4" />

frontend-web/src/components/workspace/admin/position-management-page.tsx

@@ -401,7 +401,7 @@ export function PositionManagementPage() {
   };
 
   return (
-    <div className="flex flex-col gap-4 p-6">
+    <div className="flex size-full min-h-0 flex-col gap-4 overflow-auto p-6">
       <div className="flex items-center justify-between">
         <div>
           <h1 className="text-lg font-semibold">岗位管理</h1>

frontend-web/src/components/workspace/admin/user-management-page.tsx

@@ -12,7 +12,7 @@ export function UserManagementPage() {
   const { data: users, isLoading, error } = useAllUsers(true);
 
   return (
-    <div className="flex flex-col gap-6 p-6">
+    <div className="flex size-full min-h-0 flex-col gap-6 overflow-auto p-6">
       <SettingsSection
         title={t.adminUsers.title}
         description={t.adminUsers.description}

frontend-web/src/components/workspace/agents/agent-card.tsx

@@ -229,6 +229,10 @@ export function AgentCard({ agent, layout = "card", onPublisherClick }: AgentCar
   );
   const [editPublished, setEditPublished] = useState(agent.published);
   const [editIsPrivate, setEditIsPrivate] = useState(agent.is_private);
+  // 会商席位「技能识别强化」开关（弱模型补偿）。默认关。
+  const [editSeatSkillDirective, setEditSeatSkillDirective] = useState(
+    agent.seat_skill_directive ?? false,
+  );
   const [editSquareId, setEditSquareId] = useState(agent.square_id ?? "");
   const [publishPickerOpen, setPublishPickerOpen] = useState(false);
   const { data: publishSquares } = usePublishSquares();
@@ -274,6 +278,7 @@ export function AgentCard({ agent, layout = "card", onPublisherClick }: AgentCar
     setEditSquareId(agent.square_id ?? "");
     setSelectedSkills(agent.skills ?? []);
     setEditCommonQuestions(normalizeAgentQuestions(agent.common_questions));
+    setEditSeatSkillDirective(agent.seat_skill_directive ?? false);
   }, [
     agent.common_questions,
     agent.description,
@@ -282,6 +287,7 @@ export function AgentCard({ agent, layout = "card", onPublisherClick }: AgentCar
     agent.published,
     agent.square_id,
     agent.skills,
+    agent.seat_skill_directive,
     editOpen,
   ]);
 
@@ -295,6 +301,8 @@ export function AgentCard({ agent, layout = "card", onPublisherClick }: AgentCar
     if (agentDetail) {
       setEditSoul(agentDetail.soul ?? "");
       setEditCommonQuestions(normalizeAgentQuestions(agentDetail.common_questions));
+      // 列表响应不带 config 额外字段（seat_skill_directive 为 null），详情才有真值。
+      setEditSeatSkillDirective(agentDetail.seat_skill_directive ?? false);
     } else {
       setEditSoul(agent.soul ?? "");
     }
@@ -386,6 +394,8 @@ export function AgentCard({ agent, layout = "card", onPublisherClick }: AgentCar
       request.skills = selectedSkills;
     if (JSON.stringify(nextQuestions) !== JSON.stringify(baselineQuestions))
       request.common_questions = nextQuestions;
+    if (editSeatSkillDirective !== ((agentDetail?.seat_skill_directive ?? agent.seat_skill_directive) ?? false))
+      request.seat_skill_directive = editSeatSkillDirective;
 
     if (Object.keys(request).length === 0) {
       setEditOpen(false);
@@ -960,6 +970,19 @@ export function AgentCard({ agent, layout = "card", onPublisherClick }: AgentCar
                 onChange={setEditCommonQuestions}
               />
             </div>
+            <div className="flex items-center justify-between gap-3 rounded-md border p-3">
+              <div>
+                <p className="text-sm font-medium">会商技能识别强化</p>
+                <p className="text-muted-foreground text-xs">
+                  作为会商席位时，把已配置技能（含 SKILL.md 路径与「先 read_file
+                  再用」硬指令）拼进任务，补偿弱模型不识别技能。也可在业务链条配置里打开（任一即生效）。
+                </p>
+              </div>
+              <Switch
+                checked={editSeatSkillDirective}
+                onCheckedChange={setEditSeatSkillDirective}
+              />
+            </div>
             <div className="flex items-center justify-between rounded-md border p-3">
               <div>
                 <p className="text-sm font-medium">公开发布</p>

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

@@ -0,0 +1,620 @@
+"use client";
+
+import {
+  Bot,
+  ChevronDown,
+  Download,
+  FileJson,
+  FileText,
+  Loader2,
+  MessageSquare,
+  MoreHorizontal,
+  Pencil,
+  Pin,
+  PinOff,
+  Search,
+  Share2,
+  Star,
+  Trash2,
+  X,
+} from "lucide-react";
+import Link from "next/link";
+import { useParams, usePathname, useRouter } from "next/navigation";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { toast } from "sonner";
+
+import { agentColor } from "@/components/workspace/agent-icon-color";
+import { Button } from "@/components/ui/button";
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuSeparator,
+  DropdownMenuSub,
+  DropdownMenuSubContent,
+  DropdownMenuSubTrigger,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { ShareConversationDialog } from "@/components/workspace/thread-share-dialogs";
+import { useTheme } from "@/contexts/ThemeContext";
+import { useAgentsPaginated } from "@/core/agents";
+import { getAPIClient } from "@/core/api";
+import { useI18n } from "@/core/i18n/hooks";
+import { useRouteBase } from "@/core/route-base";
+import { usePublishSquares } from "@/core/system-settings/hooks";
+import {
+  exportThreadAsJSON,
+  exportThreadAsMarkdown,
+} from "@/core/threads/export";
+import {
+  useDeleteThread,
+  useRenameThread,
+  useThreads,
+  useToggleThreadFavorite,
+  useToggleThreadPin,
+} from "@/core/threads/hooks";
+import type { AgentThread, AgentThreadState } from "@/core/threads/types";
+import {
+  isThreadFavorite,
+  isThreadPinned,
+  sortThreadsPinnedFirst,
+  titleOfThread,
+  usePathOfThread,
+} from "@/core/threads/utils";
+import { env } from "@/env";
+import { desensitize } from "@/lib/desensitize";
+import { isIMEComposing } from "@/lib/ime";
+import { cn } from "@/lib/utils";
+
+/** 「我的」作用域的下拉选项值；其余选项值为各发布广场（publish square）的 id。 */
+const MINE_SCOPE = "mine";
+
+// 列表一次拉取的条数。超出时底部出现「查看全部」入口，跳到完整的智能体管理页，
+// 避免静默截断。侧边栏只做快速切换，不在此分页。
+const LIST_PAGE_SIZE = 50;
+
+// 「最近的对话」未搜索时最多展示条数（与首页「通用问答」左栏一致）。
+const MAX_RECENT_CHATS = 10;
+
+/**
+ * 智能体问答页左侧「智能体列表 + 最近对话」栏（参考首页通用问答左栏）。
+ *
+ * 自上而下：
+ *   1. 顶部下拉：选「我的」（默认，= 我创建/收藏的）或任一「广场」（发布广场），
+ *      与「智能体管理」页主标签一致；下方为智能体名称模糊搜索框。
+ *   2. 智能体列表：所选作用域下的智能体；点击进入该智能体的新对话。当前智能体高亮。
+ *   3. 最近的对话：跨智能体的近期会话（参考首页），点击打开；支持重命名/置顶/收藏/
+ *      分享/导出/删除。当前会话高亮。
+ *
+ * 仅在独立的智能体问答整页展示；任务工作区 / zzJC·zzXD 模块 / 嵌入态不展示。
+ */
+export function AgentChatSidebar({ activeAgentId }: { activeAgentId?: string }) {
+  const { t } = useI18n();
+  const routeBase = useRouteBase();
+  const { theme } = useTheme();
+  const isDark = theme === "dark";
+
+  const { data: publishSquares } = usePublishSquares();
+  // 每个发布广场对应一个下拉选项；后端至少返回一个内置默认广场。
+  const squares = useMemo(
+    () => publishSquares?.squares ?? [],
+    [publishSquares?.squares],
+  );
+
+  // 作用域：MINE_SCOPE 或某个广场 id。默认「我的」。
+  const [scope, setScope] = useState<string>(MINE_SCOPE);
+
+  // 模糊搜索智能体名称：防抖 300ms 后走服务端 search（后端按原始名 / 脱敏名匹配），
+  // 在当前来源（我的 / 某广场）内过滤，能搜全量而非仅当前 50 条。
+  const [searchInput, setSearchInput] = useState("");
+  const [search, setSearch] = useState("");
+  useEffect(() => {
+    const timer = setTimeout(() => setSearch(searchInput.trim()), 300);
+    return () => clearTimeout(timer);
+  }, [searchInput]);
+
+  // 「智能体」区可收起（持久化）；收起后只留标题栏，下方「最近的对话」占满剩余空间。
+  const [agentsCollapsed, setAgentsCollapsed] = useState(
+    () =>
+      typeof window !== "undefined" &&
+      localStorage.getItem("agent-chat-sidebar:agents-collapsed") === "true",
+  );
+  const toggleAgents = () =>
+    setAgentsCollapsed((v) => {
+      localStorage.setItem("agent-chat-sidebar:agents-collapsed", String(!v));
+      return !v;
+    });
+
+  // 若所选广场被管理员删除，回退到「我的」，避免指向不存在的广场。
+  useEffect(() => {
+    if (
+      scope !== MINE_SCOPE &&
+      squares.length > 0 &&
+      !squares.some((sq) => sq.id === scope)
+    ) {
+      setScope(MINE_SCOPE);
+    }
+  }, [scope, squares]);
+
+  const isMine = scope === MINE_SCOPE;
+  const { agents, total, isLoading, isFetching } = useAgentsPaginated({
+    scope: isMine ? "mine" : "square",
+    sort: "time_desc",
+    page: 1,
+    pageSize: LIST_PAGE_SIZE,
+    square: isMine ? undefined : scope,
+    search: search || undefined,
+  });
+
+  return (
+    // 配色与 AgentModuleSidebar 一致：浅色白底，深蓝主题半透明深蓝玻璃面板。
+    <aside className="flex h-full w-(--sidebar-width) shrink-0 flex-col overflow-hidden border-r border-border/70 bg-white text-foreground backdrop-blur-md dark:border-[#2b8ffe]/45 dark:bg-[#032650]/80">
+      {/* 智能体（上半，可收起）。展开时：标题栏 + 来源下拉/名称搜索 + 列表；
+          收起时只留标题栏，下方「最近的对话」占满剩余空间。 */}
+      <div
+        className={cn(
+          "flex flex-col",
+          agentsCollapsed ? "shrink-0" : "min-h-0 flex-[3]",
+        )}
+      >
+        <button
+          type="button"
+          onClick={toggleAgents}
+          className="text-foreground/80 hover:bg-accent/40 flex shrink-0 items-center justify-between border-b border-border/60 px-3 py-2.5 text-[12px] font-semibold transition-colors select-none"
+          title={agentsCollapsed ? "展开智能体" : "收起智能体"}
+        >
+          <span>智能体</span>
+          <ChevronDown
+            className={cn(
+              "text-muted-foreground size-4 shrink-0 transition-transform duration-200",
+              agentsCollapsed && "-rotate-90",
+            )}
+          />
+        </button>
+
+        {!agentsCollapsed && (
+          <>
+            {/* 来源下拉（我的 / 各广场）+ 智能体名称模糊搜索 */}
+            <div className="shrink-0 space-y-2 border-b border-border/60 px-3 py-2.5">
+              <Select value={scope} onValueChange={setScope}>
+                <SelectTrigger className="h-9 w-full text-sm" title="切换智能体来源">
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent position="popper" side="bottom" sideOffset={4}>
+                  <SelectItem value={MINE_SCOPE}>我的</SelectItem>
+                  {squares.map((sq) => (
+                    <SelectItem key={sq.id} value={sq.id}>
+                      {sq.name}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              <div className="relative">
+                <Search className="text-muted-foreground pointer-events-none absolute top-1/2 left-2.5 size-3.5 -translate-y-1/2" />
+                <Input
+                  value={searchInput}
+                  onChange={(e) => setSearchInput(e.target.value)}
+                  placeholder="搜索智能体名称"
+                  className="h-9 pl-8 pr-8 text-sm"
+                  aria-label="搜索智能体名称"
+                />
+                {searchInput && (
+                  <button
+                    type="button"
+                    onClick={() => setSearchInput("")}
+                    className="text-muted-foreground hover:text-foreground absolute top-1/2 right-2 -translate-y-1/2"
+                    title="清除"
+                    aria-label="清除搜索"
+                  >
+                    <X className="size-3.5" />
+                  </button>
+                )}
+              </div>
+            </div>
+
+            {/* 智能体列表（独立滚动） */}
+            <div className="flex min-h-0 flex-1 flex-col overflow-y-auto px-2 py-3">
+              {isLoading && agents.length === 0 ? (
+                <div className="text-muted-foreground flex h-24 items-center justify-center gap-2 text-xs">
+                  <Loader2 className="size-3.5 animate-spin" />
+                  加载中…
+                </div>
+              ) : agents.length === 0 ? (
+                <p className="px-3 py-1.5 text-xs text-muted-foreground/70">
+                  {search
+                    ? "未找到匹配的智能体"
+                    : isMine
+                      ? "暂无智能体"
+                      : "该广场暂无智能体"}
+                </p>
+              ) : (
+                <div
+                  className={cn(
+                    "flex flex-col gap-1 transition-opacity",
+                    isFetching && "opacity-60",
+                  )}
+                >
+                  {agents.map((agent) => {
+                    const href = `${routeBase}/agents/${agent.id}/chats/new`;
+                    const isActive = agent.id === activeAgentId;
+                    const { from, to } = agentColor(agent.id, isDark);
+                    return (
+                      <Link
+                        key={agent.id}
+                        href={href}
+                        className={cn(
+                          "group relative flex w-full items-start gap-2.5 rounded-xl border px-2.5 py-2 transition-colors",
+                          isActive
+                            ? "border-primary/40 bg-primary/5"
+                            : "border-transparent hover:border-border hover:bg-accent/50",
+                        )}
+                      >
+                        <span
+                          className="mt-0.5 flex size-9 shrink-0 items-center justify-center rounded-lg text-white shadow-sm"
+                          style={{
+                            backgroundImage: `linear-gradient(135deg, ${from}, ${to})`,
+                          }}
+                        >
+                          <Bot className="size-[18px]" />
+                        </span>
+                        <span className="min-w-0 flex-1">
+                          <span
+                            className={cn(
+                              "block truncate text-[13px] font-semibold",
+                              isActive ? "text-primary" : "text-foreground",
+                            )}
+                          >
+                            {desensitize(agent.name)}
+                          </span>
+                          <span className="mt-0.5 block truncate text-[11px] leading-snug text-muted-foreground">
+                            {agent.description
+                              ? desensitize(agent.description)
+                              : "智能体助手"}
+                          </span>
+                        </span>
+                        {isActive && (
+                          <span className="absolute top-1/2 right-1 h-6 w-1 -translate-y-1/2 rounded-full bg-primary" />
+                        )}
+                      </Link>
+                    );
+                  })}
+                  {/* 超出一页时引导到完整的智能体管理页（不在侧边栏静默截断） */}
+                  {total > agents.length && (
+                    <Link
+                      href={`${routeBase}/agents`}
+                      className="text-muted-foreground hover:text-foreground hover:bg-accent/50 mt-0.5 rounded-lg px-3 py-1.5 text-center text-xs transition-colors"
+                    >
+                      共 {total} 个，查看全部 →
+                    </Link>
+                  )}
+                </div>
+              )}
+            </div>
+          </>
+        )}
+      </div>
+
+      {/* 最近的对话（下半，独立滚动）—— 参考首页通用问答左栏 */}
+      <RecentChatsPane activeAgentId={activeAgentId} />
+    </aside>
+  );
+}
+
+/**
+ * 「最近的对话」面板（参考首页 GeneralQaSidebar 的「最近的对话」区块）。
+ * 跨智能体的近期会话，点击打开；支持重命名/置顶/收藏/分享/导出/删除。
+ */
+function RecentChatsPane({ activeAgentId }: { activeAgentId?: string }) {
+  const { t } = useI18n();
+  const pathname = usePathname();
+  const router = useRouter();
+  const pathOf = usePathOfThread();
+
+  const { thread_id: threadIdFromPath } = useParams<{ thread_id: string }>();
+  const { data: threads = [] } = useThreads();
+  const { mutate: deleteThread } = useDeleteThread();
+  const { mutate: renameThread } = useRenameThread();
+  const { toggle: togglePin } = useToggleThreadPin();
+  const { toggle: toggleFavorite } = useToggleThreadFavorite();
+
+  const [query, setQuery] = useState("");
+  const [renameDialogOpen, setRenameDialogOpen] = useState(false);
+  const [renameThreadId, setRenameThreadId] = useState<string | null>(null);
+  const [renameValue, setRenameValue] = useState("");
+  const [shareThreadId, setShareThreadId] = useState<string | null>(null);
+
+  // 排除调度/引导/会商类会话，与首页一致；置顶优先。
+  const visibleThreads = useMemo(
+    () =>
+      sortThreadsPinnedFirst(
+        threads.filter(
+          (thread) =>
+            thread.metadata?.thread_type !== "scheduler" &&
+            thread.metadata?.thread_type !== "bootstrap" &&
+            thread.metadata?.thread_type !== "roundtable",
+        ),
+      ),
+    [threads],
+  );
+
+  const filteredThreads = useMemo(() => {
+    const q = query.trim().toLowerCase();
+    const list = q
+      ? visibleThreads.filter((thread) =>
+          titleOfThread(thread, t.pages.newChat).toLowerCase().includes(q),
+        )
+      : visibleThreads;
+    return q ? list : list.slice(0, MAX_RECENT_CHATS);
+  }, [visibleThreads, query, t.pages.newChat]);
+
+  const handleDelete = useCallback(
+    (threadId: string) => {
+      deleteThread({ threadId });
+      if (threadId === threadIdFromPath) {
+        const threadIndex = threads.findIndex((th) => th.thread_id === threadId);
+        let nextThreadPath = pathOf("new", { agent_id: activeAgentId });
+        if (threadIndex > -1) {
+          if (threads[threadIndex + 1]) {
+            nextThreadPath = pathOf(threads[threadIndex + 1]!);
+          } else if (threads[threadIndex - 1]) {
+            nextThreadPath = pathOf(threads[threadIndex - 1]!);
+          }
+        }
+        void router.push(nextThreadPath);
+      }
+    },
+    [activeAgentId, deleteThread, pathOf, router, threadIdFromPath, threads],
+  );
+
+  const handleRenameClick = useCallback(
+    (threadId: string, currentTitle: string) => {
+      setRenameThreadId(threadId);
+      setRenameValue(currentTitle);
+      setRenameDialogOpen(true);
+    },
+    [],
+  );
+
+  const handleRenameSubmit = useCallback(() => {
+    if (renameThreadId && renameValue.trim()) {
+      renameThread({ threadId: renameThreadId, title: renameValue.trim() });
+      setRenameDialogOpen(false);
+      setRenameThreadId(null);
+      setRenameValue("");
+    }
+  }, [renameThread, renameThreadId, renameValue]);
+
+  const handleExport = useCallback(
+    async (thread: AgentThread, format: "markdown" | "json") => {
+      try {
+        const apiClient = getAPIClient();
+        const state = await apiClient.threads.getState<AgentThreadState>(
+          thread.thread_id,
+        );
+        const messages = state.values?.messages ?? [];
+        if (messages.length === 0) {
+          toast.error(t.conversation.noMessages);
+          return;
+        }
+        if (format === "markdown") exportThreadAsMarkdown(thread, messages);
+        else exportThreadAsJSON(thread, messages);
+        toast.success(t.common.exportSuccess);
+      } catch {
+        toast.error("Failed to export conversation");
+      }
+    },
+    [t],
+  );
+
+  const isStatic = env.NEXT_PUBLIC_STATIC_WEBSITE_ONLY === "true";
+
+  return (
+    <div className="flex min-h-0 flex-[2] flex-col overflow-y-auto border-t border-border/60 px-2 py-3">
+      <h2 className="mb-1 flex items-center gap-1.5 px-3 py-1 text-[11px] font-semibold tracking-[0.04em] text-muted-foreground/80 select-none">
+        <span>{t.sidebar.recentChats}</span>
+        <span className="rounded-full bg-muted px-1.5 py-0.5 text-[10px] font-normal text-muted-foreground tabular-nums">
+          {visibleThreads.length}
+        </span>
+      </h2>
+
+      {/* 历史会话搜索框 */}
+      <div className="relative mb-1.5 px-1">
+        <Search className="text-muted-foreground/60 pointer-events-none absolute top-1/2 left-3.5 size-3.5 -translate-y-1/2" />
+        <Input
+          value={query}
+          onChange={(e) => setQuery(e.target.value)}
+          placeholder="搜索历史会话…"
+          className="h-8 rounded-lg border-border bg-card pl-8 text-[12px]"
+        />
+      </div>
+
+      <div className="flex flex-col gap-0.5">
+        {filteredThreads.length === 0 ? (
+          <div className="text-muted-foreground/70 px-3 py-4 text-center text-[12px]">
+            {query ? "没有匹配的会话" : t.chats.noChats}
+          </div>
+        ) : (
+          filteredThreads.map((thread) => {
+            const href = pathOf(thread);
+            const isActive = href === pathname;
+            const pinned = isThreadPinned(thread);
+            const favorited = isThreadFavorite(thread);
+            return (
+              <div
+                key={thread.thread_id}
+                className="group/item relative flex items-center"
+              >
+                <Link
+                  href={href}
+                  className={cn(
+                    "relative flex h-9 min-w-0 flex-1 items-center gap-2 rounded-lg px-2.5 text-[13px] transition-colors",
+                    isActive
+                      ? "border border-primary/40 bg-primary/5 font-medium text-primary"
+                      : "text-muted-foreground hover:bg-accent/60 hover:text-foreground",
+                  )}
+                >
+                  <MessageSquare
+                    className={cn(
+                      "size-3.5 shrink-0",
+                      isActive ? "text-primary" : "text-muted-foreground/70",
+                    )}
+                  />
+                  {pinned && (
+                    <Pin className="text-muted-foreground/70 size-3 shrink-0" />
+                  )}
+                  <span className="truncate">
+                    {desensitize(titleOfThread(thread, t.pages.newChat))}
+                  </span>
+                  {isActive && (
+                    <span className="absolute top-1/2 right-1 h-5 w-1 -translate-y-1/2 rounded-full bg-primary" />
+                  )}
+                </Link>
+                {!isStatic && (
+                  <DropdownMenu>
+                    <DropdownMenuTrigger asChild>
+                      <button
+                        type="button"
+                        className="text-muted-foreground hover:bg-background group-hover/item:opacity-100 data-[state=open]:opacity-100 absolute right-1 flex size-6 items-center justify-center rounded-md opacity-0 transition-opacity"
+                      >
+                        <MoreHorizontal className="size-4" />
+                        <span className="sr-only">{t.common.more}</span>
+                      </button>
+                    </DropdownMenuTrigger>
+                    <DropdownMenuContent
+                      className="w-48 rounded-lg"
+                      side="right"
+                      align="start"
+                    >
+                      <DropdownMenuItem
+                        onSelect={() =>
+                          handleRenameClick(
+                            thread.thread_id,
+                            titleOfThread(thread, t.pages.newChat),
+                          )
+                        }
+                      >
+                        <Pencil className="text-muted-foreground" />
+                        <span>{t.common.rename}</span>
+                      </DropdownMenuItem>
+                      <DropdownMenuItem
+                        onSelect={() => togglePin(thread.thread_id, !pinned)}
+                      >
+                        {pinned ? (
+                          <PinOff className="text-muted-foreground" />
+                        ) : (
+                          <Pin className="text-muted-foreground" />
+                        )}
+                        <span>{pinned ? t.common.unpin : t.common.pin}</span>
+                      </DropdownMenuItem>
+                      <DropdownMenuItem
+                        onSelect={() =>
+                          toggleFavorite(thread.thread_id, !favorited)
+                        }
+                      >
+                        <Star
+                          className={
+                            favorited
+                              ? "fill-amber-400 text-amber-400"
+                              : "text-muted-foreground"
+                          }
+                        />
+                        <span>
+                          {favorited ? t.common.unfavorite : t.common.favorite}
+                        </span>
+                      </DropdownMenuItem>
+                      <DropdownMenuItem
+                        onSelect={() => setShareThreadId(thread.thread_id)}
+                      >
+                        <Share2 className="text-muted-foreground" />
+                        <span>{t.common.share}</span>
+                      </DropdownMenuItem>
+                      <DropdownMenuSub>
+                        <DropdownMenuSubTrigger>
+                          <Download className="text-muted-foreground" />
+                          <span>{t.common.export}</span>
+                        </DropdownMenuSubTrigger>
+                        <DropdownMenuSubContent>
+                          <DropdownMenuItem
+                            onSelect={() => handleExport(thread, "markdown")}
+                          >
+                            <FileText className="text-muted-foreground" />
+                            <span>{t.common.exportAsMarkdown}</span>
+                          </DropdownMenuItem>
+                          <DropdownMenuItem
+                            onSelect={() => handleExport(thread, "json")}
+                          >
+                            <FileJson className="text-muted-foreground" />
+                            <span>{t.common.exportAsJSON}</span>
+                          </DropdownMenuItem>
+                        </DropdownMenuSubContent>
+                      </DropdownMenuSub>
+                      <DropdownMenuSeparator />
+                      <DropdownMenuItem
+                        onSelect={() => handleDelete(thread.thread_id)}
+                      >
+                        <Trash2 className="text-muted-foreground" />
+                        <span>{t.common.delete}</span>
+                      </DropdownMenuItem>
+                    </DropdownMenuContent>
+                  </DropdownMenu>
+                )}
+              </div>
+            );
+          })
+        )}
+      </div>
+
+      {/* 重命名弹窗 */}
+      <Dialog open={renameDialogOpen} onOpenChange={setRenameDialogOpen}>
+        <DialogContent className="sm:max-w-[425px]">
+          <DialogHeader>
+            <DialogTitle>{t.common.rename}</DialogTitle>
+          </DialogHeader>
+          <div className="py-4">
+            <Input
+              value={renameValue}
+              onChange={(e) => setRenameValue(e.target.value)}
+              placeholder={t.common.rename}
+              onKeyDown={(e) => {
+                if (e.key === "Enter" && !isIMEComposing(e)) {
+                  e.preventDefault();
+                  handleRenameSubmit();
+                }
+              }}
+            />
+          </div>
+          <DialogFooter>
+            <Button variant="outline" onClick={() => setRenameDialogOpen(false)}>
+              {t.common.cancel}
+            </Button>
+            <Button onClick={handleRenameSubmit}>{t.common.save}</Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+
+      {/* 分享弹窗 */}
+      <ShareConversationDialog
+        threadId={shareThreadId}
+        open={shareThreadId !== null}
+        onOpenChange={(o) => {
+          if (!o) setShareThreadId(null);
+        }}
+      />
+    </div>
+  );
+}

frontend-web/src/components/workspace/agents/agent-detail-panel.tsx

@@ -76,6 +76,8 @@ interface AgentDraft {
   published: boolean;
   featured: boolean;
   templateName: string;
+  /** 会商席位「技能识别强化」开关。 */
+  seatSkillDirective: boolean;
 }
 
 function draftFromAgent(agent: Agent): AgentDraft {
@@ -88,6 +90,7 @@ function draftFromAgent(agent: Agent): AgentDraft {
     published: agent.published,
     featured: agent.featured_order != null,
     templateName: agent.template_name ?? "",
+    seatSkillDirective: agent.seat_skill_directive ?? false,
   };
 }
 
@@ -131,14 +134,17 @@ export function AgentDetailPanel({
   agentName,
   onAskQuestion,
   disabled,
+  defaultCollapsed,
 }: {
   agent: Agent | null | undefined;
   agentName: string;
   onAskQuestion: (text: string) => void;
   disabled?: boolean;
+  /** 初始收起（任务工作区进入时默认收起智能体信息面板）。 */
+  defaultCollapsed?: boolean;
 }) {
   const router = useRouter();
-  const [collapsed, setCollapsed] = useState(false);
+  const [collapsed, setCollapsed] = useState(defaultCollapsed ?? false);
   const [mobileOpen, setMobileOpen] = useState(false);
   const [editing, setEditing] = useState(false);
   const [draft, setDraft] = useState<AgentDraft | null>(null);
@@ -292,6 +298,8 @@ export function AgentDetailPanel({
     if (draft.soul !== (agent.soul ?? "")) request.soul = draft.soul;
     if (draft.templateName.trim() !== (agent.template_name ?? ""))
       request.template_name = draft.templateName.trim();
+    if (draft.seatSkillDirective !== (agent.seat_skill_directive ?? false))
+      request.seat_skill_directive = draft.seatSkillDirective;
     if (nextPublished !== agent.published) request.published = nextPublished;
     if (JSON.stringify(draft.skills) !== JSON.stringify(agent.skills ?? []))
       request.skills = draft.skills;
@@ -558,6 +566,21 @@ export function AgentDetailPanel({
                 配置后，对话生成的 Markdown 文件可一键发布到知识入库接口。
               </p>
             </div>
+            <div className="bg-background/60 flex items-center justify-between rounded-lg border px-3 py-2">
+              <div className="pr-3">
+                <p className="text-sm font-medium">会商技能识别强化</p>
+                <p className="text-muted-foreground text-xs">
+                  作为会商席位时，把已配置技能（含 SKILL.md 路径与「先 read_file
+                  再用」硬指令）拼进任务，补偿弱模型不识别技能。也可在业务链条配置中打开（任一即生效）。
+                </p>
+              </div>
+              <Switch
+                checked={draft.seatSkillDirective}
+                onCheckedChange={(checked) =>
+                  setDraft({ ...draft, seatSkillDirective: checked })
+                }
+              />
+            </div>
             <div className="bg-background/60 flex items-center justify-between rounded-lg border px-3 py-2">
               <div>
                 <p className="text-sm font-medium">公开发布</p>

frontend-web/src/components/workspace/agents/agent-gallery.tsx

@@ -364,7 +364,7 @@ export function AgentGallery() {
   };
 
   return (
-    <div className="flex size-full flex-col">
+    <div className="flex size-full min-h-0 flex-col">
       {/* Page header */}
       <div className="flex items-center justify-between border-b px-6 py-4">
         <div>
@@ -392,7 +392,7 @@ export function AgentGallery() {
           setSort("time_desc");
           setPublisher(null);
         }}
-        className="flex flex-1 flex-col overflow-hidden"
+        className="flex min-h-0 flex-1 flex-col overflow-hidden"
       >
         <div className="mx-6 mt-4 flex flex-col gap-3">
           <div className="flex items-center justify-between gap-3">

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

@@ -170,8 +170,10 @@ export function AgentModuleSidebar({
     });
 
   return (
-    // 背景按需求固定白色（不走 sidebar token），与全量版 GeneralQaSidebar 的卡片视觉看齐。
-    <aside className="flex h-full w-(--sidebar-width) shrink-0 flex-col overflow-hidden border-r border-border/70 bg-white text-foreground">
+    // 原有布局不变，仅做配色适配：深色下左栏改为半透明深蓝玻璃面板（对齐 .sidebar-contents：
+    // bg rgba(3,38,80,.8) + 蓝色发光边框），叠 backdrop-blur 让外壳的深蓝底图朦胧透出；
+    // 浅色保持白底。其余颜色已走语义 token 自适配。
+    <aside className="flex h-full w-(--sidebar-width) shrink-0 flex-col overflow-hidden border-r border-border/70 bg-white text-foreground backdrop-blur-md dark:border-[#2b8ffe]/45 dark:bg-[#032650]/80">
       {onOpenSettings && (
         <div className="flex shrink-0 items-center justify-between border-b border-border/60 px-3 py-2">
           <span className="text-xs font-semibold text-foreground/80">智能体</span>

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

@@ -300,8 +300,10 @@ export function GeneralQaSidebar() {
   const isStatic = env.NEXT_PUBLIC_STATIC_WEBSITE_ONLY === "true";
 
   return (
-    // 背景走 sidebar token（浅主题=白、深蓝主题=深蓝），不要写死 bg-white，否则全量版深蓝主题下侧栏仍是白底。
-    <div className="flex h-full min-h-0 flex-col bg-sidebar text-sidebar-foreground">
+    // 背景走 sidebar token（浅主题=白、浅蓝主题=浅蓝）；深蓝(.dark)主题下由 gq-sidebar
+    // 改为「深蓝主题底图 + 半透明蓝罩」玻璃面板（见 globals.css），与右侧 workspace-chat-bg
+    // 主区同底图、略深一档作面板区分，不要写死 bg-white。
+    <div className="gq-sidebar flex h-full min-h-0 flex-col bg-sidebar text-sidebar-foreground">
       {/* ── 顶部：新对话胶囊 + 收起按钮 ── */}
       <div className="flex items-center gap-2 px-3 pt-3 pb-2">
         {/* 新对话按钮：完全自定义样式（不复用 Button variant）。borderColor / color 走

frontend-web/src/components/workspace/settings/appearance-settings-page.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { DropletIcon, LayoutGridIcon, LayoutIcon, ListIcon, MoonIcon, PanelLeftIcon, SunIcon } from "lucide-react";
-import { useMemo, type ComponentType, type SVGProps } from "react";
+import { useMemo, useState, type ComponentType, type SVGProps } from "react";
 import { useNavigate } from "react-router-dom";
 import { toast } from "sonner";
 
@@ -20,6 +20,8 @@ import { Separator } from "@/components/ui/separator";
 import { Switch } from "@/components/ui/switch";
 import { Textarea } from "@/components/ui/textarea";
 import { getStoredAuth } from "@/core/auth";
+import { migrateAuthToSession } from "@/core/auth/scoped-storage";
+import { isIsolatedSession, setIsolatedSession } from "@/core/embed/embed-session";
 import { enUS, isLocale, zhCN, type Locale } from "@/core/i18n";
 import { useI18n } from "@/core/i18n/hooks";
 import { useLocalSettings } from "@/core/settings";
@@ -64,6 +66,29 @@ export function AppearanceSettingsPage({ onClose }: { onClose?: () => void }) {
   const cleanupWords =
     citationDisplay?.cleanup_words ?? settings.display.citationCleanupWords ?? [];
 
+  // 独立登录会话（本标签页）：开关切换鉴权存储 localStorage ↔ sessionStorage（见 scoped-storage）。
+  const [isolatedSession, setIsolatedSessionState] = useState(() => isIsolatedSession());
+  const handleToggleIsolatedSession = (checked: boolean) => {
+    if (checked) {
+      // 先把当前账号从 localStorage 快照搬进 sessionStorage，再翻标志，避免切换存储后被登出。
+      migrateAuthToSession();
+      setIsolatedSession(true);
+      setIsolatedSessionState(true);
+      toast.success("已开启独立登录会话", {
+        description:
+          "本标签页的登录已与其它标签页隔离：在别的窗口登录或切换其它账号都不会影响这里，你也可以在此单独登录另一个账号。该独立会话只存在于当前标签页，关闭此标签后即结束（需重新登录）。",
+        duration: 9000,
+      });
+    } else {
+      setIsolatedSession(false);
+      setIsolatedSessionState(false);
+      toast.info("已关闭独立登录会话", {
+        description: "本标签页恢复与其它标签页共享同一登录。如页面显示未及时同步，请刷新本页。",
+        duration: 6000,
+      });
+    }
+  };
+
   const handleSetGlobalDefault = async (
     value: "light" | "dark" | "lightblue",
   ) => {
@@ -395,6 +420,28 @@ export function AppearanceSettingsPage({ onClose }: { onClose?: () => void }) {
 
       <Separator />
 
+      <SettingsSection
+        title="登录会话"
+        description="控制本标签页的登录身份是否与浏览器其它标签页隔离。"
+      >
+        <div className="flex items-start justify-between gap-4 rounded-lg border p-4">
+          <div>
+            <div className="text-sm font-medium">独立登录会话（本标签页）</div>
+            <p className="text-muted-foreground mt-1 max-w-md text-xs leading-relaxed">
+              开启后，本标签页的登录状态仅保存在当前标签页：在别的窗口登录或切换其它账号都不会影响这里，
+              你也可以在此单独登录另一个账号。关闭浏览器标签后该独立会话即结束（需重新登录）。
+            </p>
+          </div>
+          <Switch
+            checked={isolatedSession}
+            onCheckedChange={handleToggleIsolatedSession}
+            aria-label="独立登录会话"
+          />
+        </div>
+      </SettingsSection>
+
+      <Separator />
+
       <SettingsSection
         title="对话体验"
         description="问答过程中的辅助显示。"

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

@@ -58,6 +58,10 @@ export interface Agent {
   /** 入库模板名（外部知识入库接口的 templateName）。配置后该智能体会话中的
    * Markdown 产物右上角出现"发布入库"按钮。空/缺省 = 不支持入库。 */
   template_name?: string | null;
+  /** 会商席位「技能识别强化」开关。作为会商席位运行时，是否把本智能体配置的技能
+   * (名称 + SKILL.md 路径 + 必须先 read_file 的硬指令) 拼进本轮任务以补偿弱模型。
+   * 与业务链条同名开关取 OR。null/false = 关 (默认)。 */
+  seat_skill_directive?: boolean | null;
   tags?: Tag[];
   featured_order?: number | null;
   /** Whether the current user has favorited (收藏) this agent. */
@@ -91,6 +95,8 @@ export interface CreateAgentRequest {
   tool_groups?: string[] | null;
   common_questions?: AgentQuestion[] | null;
   template_name?: string | null;
+  /** 会商席位「技能识别强化」开关；缺省/false = 关。 */
+  seat_skill_directive?: boolean | null;
 }
 
 export interface UpdateAgentRequest {
@@ -106,4 +112,6 @@ export interface UpdateAgentRequest {
   common_questions?: AgentQuestion[] | null;
   /** 入库模板名；传空字符串表示清除。 */
   template_name?: string | null;
+  /** 会商席位「技能识别强化」开关；缺省/false = 关。 */
+  seat_skill_directive?: boolean | null;
 }

frontend-web/src/core/auth/dashboard-input.ts

@@ -0,0 +1,223 @@
+/**
+ * 大屏绘制智能体「独立页面」的**输入 JSON** 适配 seam。
+ *
+ * 设计意图：深链 `?taskId=` 模式下，后端提供「研判情报报告」接口
+ *   GET `{VITE_AIPI_CONSUMER_URL}/cop/selectSqReport?taskId=`
+ * 返回该任务的多类情报内容；本页把它**提取成干净的结构化 JSON** 交给智能体分析
+ * → 产出 report-json → 绘制大屏（react / html）。
+ *
+ * 接口返回结构：`{ state, msg, data: [{ id, taskId, ..., contentJson, categoryType }] }`，
+ * 其中 `contentJson` 是**被转义的 JSON 字符串**，`categoryType` 形如「敌情关键事件 JSON」。
+ * 本模块 `extractSqReport` 把每条的 `contentJson` 反序列化、按 `categoryType` 归类，
+ * 拼成 `{ taskId, categories: { 敌情关键事件: [...], 决心建议: {...}, ... } }` 喂给智能体。
+ *
+ * ⚠️ 真实接口现在还**请求不到**：通过 `VITE_MOCK_SQ_REPORT=true`（见 `utils/request.ts`）
+ * 走后端给的样例假数据（`sq-report-mock.json`），机制与 cop-task-detail 假数据一致。
+ * 联调通过后把该 env 置 false 即走真实接口；接口/数据若有变只需改 `extractSqReport`。
+ */
+
+import { requestCrudService } from "@/service/request-axios-service";
+import { readCopTaskDetail } from "@/core/auth/task-deeplink";
+
+/** 本页输入 JSON 暂存的 sessionStorage key（拉取一次后复用，避免重复请求）。 */
+export const DASHBOARD_INPUT_STORAGE_KEY = "dashboard.inputJson";
+
+/**
+ * 🧪 演示用模拟业务 JSON —— JSON 接口未就绪、也没有登录任务详情时的兜底输入。
+ * 让大屏页可立即跑通：智能体分析这份数据 → report-json → 渲染大屏。
+ * ⚠️ 接口就绪后删除本常量及其兜底引用。
+ */
+export const DEMO_DASHBOARD_INPUT = {
+  taskId: "DEMO-涉台舆情",
+  taskName: "2026 第一季度涉台舆情态势研判",
+  taskContent:
+    "汇总境内外多平台涉台舆情数据，研判热点叙事走势、关键行为体立场与传播渠道分布，识别风险并给出处置建议。",
+  overview:
+    "本季涉台舆情整体平稳但局部波动，'两岸交流''和平发展'类正向叙事占比上升，少数账号借军事议题制造紧张；境外智库与媒体联动放大特定框架。",
+  period: "2026-01-01 ~ 2026-03-31",
+  kpis: {
+    总信息量: 1284000,
+    日均增速: "12%",
+    正向占比: "58%",
+    负向占比: "19%",
+    识别风险点: 7,
+    覆盖平台: 12,
+  },
+  channels: [
+    { platform: "微博", share: 34 },
+    { platform: "境外社媒(X/FB)", share: 27 },
+    { platform: "短视频", share: 18 },
+    { platform: "新闻门户", share: 13 },
+    { platform: "论坛/贴吧", share: 8 },
+  ],
+  narratives: [
+    { theme: "两岸交流与融合发展", sentiment: "正向", volume: 42, trend: "up" },
+    { theme: "和平稳定·避战", sentiment: "正向", volume: 26, trend: "up" },
+    { theme: "军事演训与安全", sentiment: "中性偏负", volume: 21, trend: "flat" },
+    { theme: "外部势力介入", sentiment: "负向", volume: 11, trend: "down" },
+  ],
+  actors: [
+    { name: "主流官媒", stance: "正面引导", influence: 88, note: "议程设置与权威发布" },
+    { name: "岛内民间团体", stance: "中性多元", influence: 64, note: "交流合作类内容活跃" },
+    { name: "境外智库", stance: "负面框架", influence: 57, note: "联动媒体放大紧张叙事" },
+    { name: "自媒体大V", stance: "立场分化", influence: 49, note: "情绪化传播、易被借势" },
+  ],
+  risks: [
+    { label: "军事议题被恶意剪辑放大", level: "high" },
+    { label: "境外智库联动制造紧张框架", level: "high" },
+    { label: "个别大V情绪化带节奏", level: "mid" },
+    { label: "短视频谣言二次传播", level: "mid" },
+    { label: "节假日期间信息量骤增", level: "low" },
+  ],
+  timeline: [
+    { phase: "数据汇聚", desc: "12 平台多源采集与清洗去重" },
+    { phase: "叙事识别", desc: "聚类提炼核心叙事与情感倾向" },
+    { phase: "行为体画像", desc: "关键账号立场与影响力建模" },
+    { phase: "风险研判", desc: "识别高危议题与传播链路" },
+    { phase: "处置建议", desc: "分级响应与正向引导预案" },
+  ],
+  weeklyVolume: [
+    { week: "W1", value: 86 },
+    { week: "W2", value: 92 },
+    { week: "W3", value: 110 },
+    { week: "W4", value: 134 },
+    { week: "W5", value: 121 },
+    { week: "W6", value: 158 },
+  ],
+};
+
+/** 「研判情报报告」接口完整地址：`{VITE_AIPI_CONSUMER_URL}/cop/selectSqReport`。 */
+function sqReportUrl(): string {
+  const value = (import.meta.env as Record<string, unknown>).VITE_AIPI_CONSUMER_URL;
+  const base = typeof value === "string" ? value.replace(/\/+$/, "") : "";
+  return base ? `${base}/cop/selectSqReport` : "";
+}
+
+/** 把单条 `contentJson` 反序列化为对象/数组/原值（已是对象则原样返回）。 */
+function parseContentJson(raw: unknown): unknown {
+  if (typeof raw !== "string") return raw ?? null;
+  const text = raw.trim();
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text; // 解析失败就把原始字符串透传给智能体，让它自行理解
+  }
+}
+
+/** 去掉 categoryType 末尾的「 JSON」后缀，作为归类键（如「敌情关键事件 JSON」→「敌情关键事件」）。 */
+function categoryKey(categoryType: unknown, index: number): string {
+  const raw = typeof categoryType === "string" ? categoryType.trim() : "";
+  const cleaned = raw.replace(/\s*JSON\s*$/i, "").trim();
+  return cleaned || `分类${index + 1}`;
+}
+
+/**
+ * 把 selectSqReport 的整包响应**提取**成喂给智能体的干净结构化输入：
+ *   `{ taskId, source, categories: { [类目]: 反序列化后的内容 } }`
+ * 返回 null 表示无可用内容（调用方据此回退/不开跑）。
+ */
+export function extractSqReport(body: unknown, taskId: string): unknown | null {
+  const data = (body && typeof body === "object" ? (body as { data?: unknown }).data : null) as
+    | Array<Record<string, unknown>>
+    | undefined;
+  if (!Array.isArray(data) || data.length === 0) return null;
+  const categories: Record<string, unknown> = {};
+  data.forEach((item, index) => {
+    const content = parseContentJson(item?.contentJson);
+    if (content == null) return;
+    let key = categoryKey(item?.categoryType, index);
+    if (key in categories) key = `${key}（${index + 1}）`; // 同名类目去重保留
+    categories[key] = content;
+  });
+  if (Object.keys(categories).length === 0) return null;
+  return { taskId, source: "cop/selectSqReport", categories };
+}
+
+/**
+ * 输入 JSON 缓存**仅供开发(mock)使用**：`VITE_MOCK_SQ_REPORT==='true'` 时才读/写缓存，
+ * 避免开发反复请求样例假数据。真实接口模式（false）下不读不写缓存，**始终拉取真实数据**。
+ */
+function inputCacheEnabled(): boolean {
+  return (import.meta.env as Record<string, unknown>).VITE_MOCK_SQ_REPORT === "true";
+}
+
+/** 读取暂存的输入 JSON（仅 mock 开发模式生效，真实模式恒返回 null 以强制重新拉取）。 */
+export function readDashboardInputJson(): unknown | null {
+  if (!inputCacheEnabled()) return null;
+  try {
+    const raw = sessionStorage.getItem(DASHBOARD_INPUT_STORAGE_KEY);
+    return raw ? JSON.parse(raw) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 暂存输入 JSON（仅 mock 开发模式生效；隐私模式/quota 异常静默失败）。 */
+export function persistDashboardInputJson(data: unknown): void {
+  if (!inputCacheEnabled()) return;
+  try {
+    sessionStorage.setItem(DASHBOARD_INPUT_STORAGE_KEY, JSON.stringify(data));
+  } catch {
+    /* noop */
+  }
+}
+
+/** 用登录暂存的任务详情拼一份占位输入（接口未就绪时的回退）。 */
+function placeholderFromCopTask(taskId: string): unknown | null {
+  const detail = readCopTaskDetail();
+  if (!detail) return taskId ? { taskId } : null;
+  return {
+    taskId,
+    taskName: detail.taskName,
+    taskContent: detail.taskContent,
+    overview: detail.overview,
+    taskDirection: detail.taskDirection,
+    _note: "占位输入（真实业务 JSON 接口未就绪）",
+  };
+}
+
+/**
+ * 取本页的输入 JSON：**先请求 selectSqReport，待其返回后再交给模型抽取**。
+ *
+ * - 真实接口模式（`VITE_MOCK_SQ_REPORT=false`）：不读缓存、不兜底假数据——
+ *   **只用接口真实返回的内容**；请求失败或返回空一律返回 `null`（页面据此提示「请求失败/无数据」，
+ *   绝不拿占位/演示数据去喂模型，避免「没等接口就抽取假数据」）。
+ * - mock 开发模式（true）：走本地样例假数据（见 utils/request.ts）并缓存避免反复请求；
+ *   仅此模式在接口不可用时回退 copTaskDetail 占位 / DEMO 演示数据，保证开发能跑通。
+ */
+export async function fetchDashboardInputJson(
+  taskId: string,
+  opts?: { forceRefresh?: boolean },
+): Promise<unknown | null> {
+  const mock = inputCacheEnabled(); // true=mock/开发；false=真实接口
+  // forceRefresh（重新分析/修改时）：跳过缓存，强制重新请求接口拿**最新数据**（数据可能已变化）。
+  const cached = opts?.forceRefresh ? null : readDashboardInputJson(); // 真实模式恒 null（缓存仅开发用）
+  if (cached) return cached;
+
+  const url = sqReportUrl();
+  if (url && taskId) {
+    try {
+      // service 拦截器统一注入鉴权并返回 response.data（整包 body）。
+      // await 在此：必须**等接口返回**后才有 body 可 extract → 再由上层启动模型抽取。
+      const body = await requestCrudService.get(url, { taskId });
+      const extracted = extractSqReport(body, taskId);
+      if (extracted) {
+        persistDashboardInputJson(extracted); // 真实模式 no-op
+        return extracted;
+      }
+    } catch {
+      /* 请求失败：真实模式返回 null（见下），mock 模式落占位/DEMO */
+    }
+  }
+
+  // 真实接口模式：**不兜底假数据**。失败/空 → null，让页面提示而不是拿假数据喂模型。
+  if (!mock) return null;
+
+  // 以下兜底**仅 mock/开发模式**：copTaskDetail 占位 / DEMO 演示数据，保证开发能看效果。
+  const placeholder = placeholderFromCopTask(taskId);
+  const detail = readCopTaskDetail();
+  const resolved = detail ? placeholder : { ...DEMO_DASHBOARD_INPUT, taskId: taskId || DEMO_DASHBOARD_INPUT.taskId };
+  if (resolved) persistDashboardInputJson(resolved);
+  return resolved;
+}

frontend-web/src/core/auth/external-login.ts

@@ -9,6 +9,8 @@
  * theme 不存（直接走 ThemeContext，避免双源）。
  */
 
+import { authStorageGet, authStorageSet } from "@/core/auth/scoped-storage";
+
 export const EXTERNAL_LOGIN_STORAGE_KEYS = {
   ticket: "login.ticket",
   userId: "login.userId",
@@ -27,32 +29,25 @@ export type ExternalLoginParams = {
 
 /** 把外部跳转带来的三个参数写到 localStorage；隐私模式 / quota 异常时静默失败 */
 export function persistExternalLoginParams(params: ExternalLoginParams): void {
-  try {
-    if (params.ticket) {
-      localStorage.setItem(EXTERNAL_LOGIN_STORAGE_KEYS.ticket, params.ticket);
-    }
-    if (params.userId) {
-      localStorage.setItem(EXTERNAL_LOGIN_STORAGE_KEYS.userId, params.userId);
-    }
-    if (params.env) {
-      localStorage.setItem(EXTERNAL_LOGIN_STORAGE_KEYS.env, params.env);
-    }
-  } catch {
-    // localStorage 不可用时不阻断登录流程
+  // 嵌入(iframe)态走 sessionStorage（按标签页隔离），正常态走 localStorage —— 见 scoped-storage.ts。
+  if (params.ticket) {
+    authStorageSet(EXTERNAL_LOGIN_STORAGE_KEYS.ticket, params.ticket);
+  }
+  if (params.userId) {
+    authStorageSet(EXTERNAL_LOGIN_STORAGE_KEYS.userId, params.userId);
+  }
+  if (params.env) {
+    authStorageSet(EXTERNAL_LOGIN_STORAGE_KEYS.env, params.env);
   }
 }
 
 /** 读取持久化的外部登录参数；不可用时返回空字符串 */
 export function readExternalLoginParams(): Required<ExternalLoginParams> {
-  try {
-    return {
-      ticket: localStorage.getItem(EXTERNAL_LOGIN_STORAGE_KEYS.ticket) ?? "",
-      userId: localStorage.getItem(EXTERNAL_LOGIN_STORAGE_KEYS.userId) ?? "",
-      env: localStorage.getItem(EXTERNAL_LOGIN_STORAGE_KEYS.env) ?? "",
-    };
-  } catch {
-    return { ticket: "", userId: "", env: "" };
-  }
+  return {
+    ticket: authStorageGet(EXTERNAL_LOGIN_STORAGE_KEYS.ticket) ?? "",
+    userId: authStorageGet(EXTERNAL_LOGIN_STORAGE_KEYS.userId) ?? "",
+    env: authStorageGet(EXTERNAL_LOGIN_STORAGE_KEYS.env) ?? "",
+  };
 }
 
 /**

frontend-web/src/core/auth/index.ts

@@ -9,6 +9,12 @@ export interface LoginByUsernameResponse {
   created: boolean;
 }
 
+import {
+  authStorageGet,
+  authStorageRemove,
+  authStorageSet,
+} from "@/core/auth/scoped-storage";
+
 const AUTH_STORAGE_KEY = "deerflow.auth";
 
 function isBrowser(): boolean {
@@ -19,7 +25,8 @@ export function getStoredAuth(): LoginByUsernameResponse | null {
   if (!isBrowser()) {
     return null;
   }
-  const raw = window.localStorage.getItem(AUTH_STORAGE_KEY);
+  // 嵌入(iframe)态走 sessionStorage、正常态走 localStorage —— 隔离 iframe 登录用户与正常登录用户。
+  const raw = authStorageGet(AUTH_STORAGE_KEY);
   if (!raw) {
     return null;
   }
@@ -34,14 +41,14 @@ export function setStoredAuth(auth: LoginByUsernameResponse) {
   if (!isBrowser()) {
     return;
   }
-  window.localStorage.setItem(AUTH_STORAGE_KEY, JSON.stringify(auth));
+  authStorageSet(AUTH_STORAGE_KEY, JSON.stringify(auth));
 }
 
 export function clearStoredAuth() {
   if (!isBrowser()) {
     return;
   }
-  window.localStorage.removeItem(AUTH_STORAGE_KEY);
+  authStorageRemove(AUTH_STORAGE_KEY);
 }
 
 /** 与设置 → 个人信息页「用户名」一致：邮箱 @ 前缀，否则 user_id。 */
@@ -67,7 +74,7 @@ export function setStoredUserName(name: string | null | undefined) {
   }
   let info: Record<string, unknown> = {};
   try {
-    const raw = window.localStorage.getItem("userInfo");
+    const raw = authStorageGet("userInfo");
     if (raw) {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") {
@@ -81,7 +88,7 @@ export function setStoredUserName(name: string | null | undefined) {
     return;
   }
   info.userName = trimmed;
-  window.localStorage.setItem("userInfo", JSON.stringify(info));
+  authStorageSet("userInfo", JSON.stringify(info));
 }
 
 export function getAccessToken(): string | undefined {

frontend-web/src/core/auth/scoped-storage.ts

@@ -0,0 +1,94 @@
+/**
+ * 鉴权 / 身份存储的「按登录态隔离」选择器。
+ *
+ * 诉求：外部系统用 iframe 套用咱们的深链问答时，**iframe 里登录的用户**要和**同浏览器正常登录
+ * 的用户**完全隔离——不然 iframe 里随便登一个用户，会覆盖正常标签页的登录态（甚至触发跨标签
+ * 账号变更提示）。
+ *
+ * 根因：同源下 `localStorage` 跨所有标签页共享，鉴权 token（`deerflow.auth`）/ 身份（`userInfo`）/
+ * 外部登录参数（`login.*` / `tools_token`）都存在那里，iframe 一写就污染正常页。
+ *
+ * 方案：嵌入态（`isEmbedActive()`，见 [[embed-session]]）下，这些键改走 **sessionStorage**——它按
+ * **标签页/浏览上下文**隔离，iframe（即便同源）有自己独立的一份，写它绝不动正常标签页的
+ * localStorage，也不会触发正常页的 `storage` 事件（见 sync.tsx 的跨标签账号监听）。正常态仍走
+ * localStorage，行为零变化。
+ *
+ * 把所有受保护键的读写都收口到 `authStorage()`，保证同一标签页内读写落到同一处（嵌入态恒为
+ * sessionStorage、正常态恒为 localStorage；嵌入标志一进程内不翻转，故一致）。
+ */
+
+import { isEmbedActive, isIsolatedSession } from "@/core/embed/embed-session";
+
+/**
+ * 返回当前应使用的鉴权存储：嵌入态（iframe）**或**独立会话态（`?isolate=1`）→ sessionStorage
+ * （按标签页隔离）；否则 → localStorage（跨标签共享、持久）。非浏览器环境返回 null（调用方各自
+ * 有 SSR 守卫）。两种隔离态等价于「本标签页鉴权独立、绝不污染其它标签页登录态」，区别仅在于嵌入态
+ * 还会去 chrome / 强制主题，独立会话态只切换存储。
+ */
+export function authStorage(): Storage | null {
+  if (typeof window === "undefined") return null;
+  return isEmbedActive() || isIsolatedSession() ? window.sessionStorage : window.localStorage;
+}
+
+/** 读受保护键（嵌入态 sessionStorage / 正常态 localStorage）。 */
+export function authStorageGet(key: string): string | null {
+  try {
+    return authStorage()?.getItem(key) ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/** 写受保护键。隐私模式 / quota 异常静默失败。 */
+export function authStorageSet(key: string, value: string): void {
+  try {
+    authStorage()?.setItem(key, value);
+  } catch {
+    /* noop */
+  }
+}
+
+/** 删受保护键。 */
+export function authStorageRemove(key: string): void {
+  try {
+    authStorage()?.removeItem(key);
+  } catch {
+    /* noop */
+  }
+}
+
+/**
+ * 受 `authStorage()` 收口管理的鉴权 / 身份键：四个精确键 + `login.` 前缀（外部登录参数族
+ * ticket/userId/env/maxkeyOnlineToken/userDetailToken）。用于「开启独立会话」时把当前登录态从
+ * localStorage 快照搬进 sessionStorage，避免切换存储后被登出。
+ */
+const PROTECTED_AUTH_EXACT_KEYS = ["deerflow.auth", "userInfo", "userId", "tools_token"];
+const PROTECTED_AUTH_PREFIX = "login.";
+
+function isProtectedAuthKey(key: string): boolean {
+  return PROTECTED_AUTH_EXACT_KEYS.includes(key) || key.startsWith(PROTECTED_AUTH_PREFIX);
+}
+
+/**
+ * 把 localStorage 里的鉴权 / 身份键**快照复制**进 sessionStorage（覆盖式）。
+ *
+ * 「外观」设置开启独立会话时调用：此后 `authStorage()` 改读 sessionStorage，若不先搬一份当前账号
+ * 过去就会瞬间「未登录」。每次开启都重新快照（覆盖旧值），确保拿到的是当前 localStorage 的最新账号。
+ * 仅搬受保护键，不动 sessionStorage 里既有的本标签页专属态（embed.session / 任务上下文等）。
+ */
+export function migrateAuthToSession(): void {
+  if (typeof window === "undefined") return;
+  try {
+    const ls = window.localStorage;
+    const ss = window.sessionStorage;
+    for (let i = 0; i < ls.length; i++) {
+      const key = ls.key(i);
+      if (key && isProtectedAuthKey(key)) {
+        const value = ls.getItem(key);
+        if (value !== null) ss.setItem(key, value);
+      }
+    }
+  } catch {
+    /* noop */
+  }
+}

frontend-web/src/core/auth/sync.tsx

@@ -4,6 +4,7 @@ import { useEffect, useRef } from "react";
 import { toast } from "sonner";
 
 import { getStoredAuth } from "@/core/auth";
+import { isEmbedActive, isIsolatedSession } from "@/core/embed/embed-session";
 
 const AUTH_STORAGE_KEY = "deerflow.auth";
 const SETTLE_DELAY_MS = 1200;
@@ -21,6 +22,10 @@ export function AuthSyncWatcher() {
   const lastUserIdRef = useRef<string | null>(readUserId());
 
   useEffect(() => {
+    // 嵌入(iframe)态 / 独立会话态(?isolate=1)：鉴权走按标签页的 sessionStorage，本就不与其它标签页
+    // 共享，且不应被其它标签页的 localStorage 账号变更打扰 —— 直接不挂跨标签监听。
+    if (isEmbedActive() || isIsolatedSession()) return;
+
     let settleTimer: ReturnType<typeof setTimeout> | null = null;
 
     function evaluateSettledIdentity() {
@@ -47,6 +52,11 @@ export function AuthSyncWatcher() {
     }
 
     function handleStorage(event: StorageEvent) {
+      // 运行时若已切到独立会话（「外观」开关在挂载后才开启）：鉴权改读本标签页 sessionStorage，
+      // 不应再被其它标签页的 localStorage 账号变更打扰 —— 即时忽略，无需刷新页面。
+      if (isEmbedActive() || isIsolatedSession()) {
+        return;
+      }
       // Ignore unrelated keys and localStorage.clear(). Backend session loss is
       // handled centrally through 401 responses.
       if (event.key !== AUTH_STORAGE_KEY) {

frontend-web/src/core/auth/task-buttons.ts

@@ -0,0 +1,261 @@
+/**
+ * 任务工作区（任务深链 rwfx / 3qfx / xdfx，见 ``TaskFxWorkspace``）左侧栏的
+ * **可配置跳转按钮**。
+ *
+ * 数据源优先级：后端 ``/api/task-buttons``（全局共享、admin 整体替换）。**仅当整张表
+ * 为空（全新部署、从未保存过）**时回退到代码种子默认（``defaultTaskButtons``，从实时
+ * 任务深链配置读出 rwfx 的 4 个历史按钮，3qfx/xdfx 为空）——这样真实跳转地址通过实时
+ * config 进种子，避免写死；一旦保存过，后端即唯一数据源。
+ *
+ * 按钮两类（``linkType``）：``url`` 外链（``window.open``，可选追加 ``?id=任务id``）/
+ * ``business`` 内部切换到另一业务（复用 [[task-deeplink]] 的 ``resolveTaskDeeplinkTarget``）。
+ */
+
+import {
+  appendQueryParam,
+  type TaskDeeplinkConfig,
+} from "@/core/auth/task-deeplink-config";
+import {
+  readCopTaskDetail,
+  resolveTaskDeeplinkTarget,
+} from "@/core/auth/task-deeplink";
+
+/** 任务工作区业务码（与路由 taskBase 一一对应）。 */
+export type TaskBusiness = "rwfx" | "3qfx" | "xdfx";
+
+/** 业务元数据：每个 = 一个任务深链页面。``goPath`` 为深链 ``?goPath=`` 值；``desc`` 给管理页说明。 */
+export const TASK_BUSINESSES: {
+  code: TaskBusiness;
+  /** 页面名（tab 主标题）。 */
+  name: string;
+  /** 深链 goPath 值。 */
+  goPath: string;
+  /** 页面说明。 */
+  desc: string;
+}[] = [
+  {
+    code: "rwfx",
+    name: "任务分析",
+    goPath: "rwfx",
+    desc: "完整版任务工作区（带目的树闸门），通过 ?goPath=rwfx 进入。",
+  },
+  {
+    code: "3qfx",
+    name: "三情分析",
+    goPath: "3qfx",
+    desc: "精简版工作区（无目的树闸门），通过 ?goPath=3qfx 进入。",
+  },
+  {
+    code: "xdfx",
+    name: "行动分析",
+    goPath: "xdfx",
+    desc: "精简版工作区，通过 ?goPath=xdfx 进入（深链 taskId 实为行动id）。",
+  },
+];
+
+/** ``url``=外链 / ``business``=切换业务 / ``purpose``=弹出任务目的树表格（无需 target）。 */
+export type TaskButtonLinkType = "url" | "business" | "purpose";
+
+/** 追加的 id 取哪种：``task``=任务id（默认）/ ``action``=行动id（仅 xdfx 二者不同）。 */
+export type TaskButtonIdKind = "task" | "action";
+
+/** ``url`` 外链打开方式：``blank``=新窗口（默认）/ ``self``=当前窗口（嵌入态即当前 iframe）。 */
+export type TaskButtonOpenMode = "blank" | "self";
+
+/** 一个可配置跳转按钮。 */
+export interface TaskButton {
+  id: string;
+  business: TaskBusiness;
+  label: string;
+  linkType: TaskButtonLinkType;
+  /** ``url``=完整地址；``business``=目标业务码（如 ``3qfx``）。 */
+  target: string;
+  /** ``url`` 类型是否追加 id 查询参数。 */
+  appendTaskId: boolean;
+  /** 追加的查询参数名（如 ``id`` / ``task_id``）；空则用 ``id``。 */
+  idParam: string;
+  /**
+   * ``url`` 追加 id 时取任务id 还是行动id。仅 xdfx（行动分析）二者不同：深链原始 ``?taskId=``
+   * 实为行动id，任务id 由 action 接口解析。其它业务两者相同。
+   */
+  idKind: TaskButtonIdKind;
+  /** ``url`` 外链打开方式：``blank``=新窗口（默认）/ ``self``=当前窗口。仅 ``url`` 类型有意义。 */
+  openMode: TaskButtonOpenMode;
+  enabled: boolean;
+  sortOrder: number;
+}
+
+/** 内部切换可选的目标业务（``business`` 类型按钮的下拉项）。 */
+export const TASK_BUSINESS_TARGETS: { code: TaskBusiness; label: string }[] = [
+  { code: "3qfx", label: "三情分析" },
+  { code: "rwfx", label: "任务分析" },
+  { code: "xdfx", label: "行动分析" },
+];
+
+/**
+ * 代码种子默认按钮（仅在后端整张表为空时使用）：
+ *   - rwfx：历史 4 个按钮（编辑/下一步/3q详情，地址取自实时任务深链配置）+ 切换到三情/行动分析；
+ *   - 3qfx / xdfx：互相切换到另外两个业务。
+ * 即「三个业务都带切换按钮」。已保存过则用页面「导入默认」把缺失项补进来。
+ */
+export function defaultTaskButtons(cfg: TaskDeeplinkConfig): TaskButton[] {
+  const sw = (
+    id: string,
+    business: TaskBusiness,
+    label: string,
+    target: TaskBusiness,
+    sortOrder: number,
+  ): TaskButton => ({
+    id,
+    business,
+    label,
+    linkType: "business",
+    target,
+    appendTaskId: false,
+    idParam: "id",
+    idKind: "task",
+    openMode: "blank",
+    enabled: true,
+    sortOrder,
+  });
+  // 目的树弹框按钮（无需 target）。
+  const pz = (id: string, business: TaskBusiness, sortOrder: number): TaskButton => ({
+    id,
+    business,
+    label: "弹框查看",
+    linkType: "purpose",
+    target: "",
+    appendTaskId: false,
+    idParam: "id",
+    idKind: "task",
+    openMode: "blank",
+    enabled: true,
+    sortOrder,
+  });
+  return [
+    // rwfx（任务分析）：外链 + 切换
+    {
+      id: "rwfx-edit",
+      business: "rwfx",
+      label: "编辑",
+      linkType: "url",
+      target: cfg.treemapEditUrl,
+      appendTaskId: true,
+      idParam: "id",
+      idKind: "task",
+      openMode: "blank",
+      enabled: true,
+      sortOrder: 0,
+    },
+    {
+      id: "rwfx-next",
+      business: "rwfx",
+      label: "下一步",
+      linkType: "url",
+      target: cfg.treemapNextUrl,
+      appendTaskId: true,
+      idParam: "id",
+      idKind: "task",
+      openMode: "blank",
+      enabled: true,
+      sortOrder: 1,
+    },
+    {
+      id: "rwfx-detail3q",
+      business: "rwfx",
+      label: "3q详情",
+      linkType: "url",
+      target: cfg.detail3qUrl,
+      appendTaskId: true,
+      idParam: "id",
+      idKind: "task",
+      openMode: "blank",
+      enabled: true,
+      sortOrder: 2,
+    },
+    sw("rwfx-switch3q", "rwfx", "切换到三情分析", "3qfx", 3),
+    sw("rwfx-switchxd", "rwfx", "切换到行动分析", "xdfx", 4),
+    pz("rwfx-purpose", "rwfx", 5),
+    // 3qfx（三情分析）：切换到任务/行动分析
+    sw("3qfx-switchrw", "3qfx", "切换到任务分析", "rwfx", 0),
+    sw("3qfx-switchxd", "3qfx", "切换到行动分析", "xdfx", 1),
+    // xdfx（行动分析）：切换到任务/三情分析 + 弹框查看
+    sw("xdfx-switchrw", "xdfx", "切换到任务分析", "rwfx", 0),
+    sw("xdfx-switch3q", "xdfx", "切换到三情分析", "3qfx", 1),
+    pz("xdfx-purpose", "xdfx", 2),
+  ];
+}
+
+/**
+ * 实际生效的按钮列表：后端有任意一条记录时即以后端为准；整张表为空才回退种子默认。
+ * （与 [[敏感词管理]] 的种子语义一致：空=从未配置→用种子；非空=已配置→后端说了算，
+ * 哪怕某业务被清空也不回退。）
+ */
+export function resolveTaskButtons(
+  stored: TaskButton[],
+  cfg: TaskDeeplinkConfig,
+): TaskButton[] {
+  return stored.length > 0 ? stored : defaultTaskButtons(cfg);
+}
+
+/** 取某业务下、启用的按钮，按 sortOrder 升序。 */
+export function buttonsForBusiness(
+  buttons: TaskButton[],
+  business: TaskBusiness,
+): TaskButton[] {
+  return buttons
+    .filter((b) => b.business === business && b.enabled)
+    .sort((a, b) => a.sortOrder - b.sortOrder);
+}
+
+export interface RunTaskButtonCtx {
+  /** 任务id（xdfx 为 action 接口解析后的真实任务id；其它业务即深链原始 id）。 */
+  taskId: string;
+  /** 行动id（xdfx 深链原始 ?taskId=；其它业务通常等于 taskId）。 */
+  actionId?: string;
+  navigate: (path: string, opts?: { state?: Record<string, unknown> }) => void;
+  /** 跳转/打开失败时的提示回调（默认 noop）。 */
+  onError?: (message: string) => void;
+}
+
+/**
+ * 执行一个跳转按钮：
+ *   - ``url``：拼地址（可选追加 ``?id=``，取任务id 或行动id 视 ``idKind``）新标签打开；地址为空提示未配置。
+ *   - ``business``：复用深链解析（会按目标业务重绑任务上下文）后 ``navigate``（始终用任务id）。
+ */
+export async function runTaskButton(btn: TaskButton, ctx: RunTaskButtonCtx): Promise<void> {
+  const fail = (m: string) => ctx.onError?.(m);
+  // purpose（目的树弹框）由组件层处理（需打开 React 弹框），此处不动作。
+  if (btn.linkType === "purpose") return;
+  if (btn.linkType === "url") {
+    const base = btn.target.trim();
+    if (!base) {
+      fail(`未配置「${btn.label}」的跳转地址`);
+      return;
+    }
+    // 行动分析（xdfx）可选追加行动id；否则用任务id。行动id 缺失时回退任务id。
+    const id = btn.idKind === "action" ? ctx.actionId || ctx.taskId : ctx.taskId;
+    const param = (btn.idParam || "id").trim() || "id";
+    const url = btn.appendTaskId && id ? appendQueryParam(base, param, id) : base;
+    // 打开方式：self=当前窗口（嵌入态即当前 iframe）；否则 blank=新窗口（默认）。
+    if (btn.openMode === "self") {
+      window.location.assign(url);
+    } else {
+      window.open(url, "_blank", "noopener,noreferrer");
+    }
+    return;
+  }
+  // business：内部切换到另一业务
+  const detail = readCopTaskDetail();
+  if (!detail || !ctx.taskId) {
+    fail("缺少任务信息，无法跳转");
+    return;
+  }
+  try {
+    const target = await resolveTaskDeeplinkTarget(btn.target, detail, ctx.taskId);
+    if (target) ctx.navigate(target.path, { state: target.state });
+    else fail(`未配置「${btn.label}」对应的业务智能体`);
+  } catch {
+    fail("跳转失败，请稍后再试");
+  }
+}

frontend-web/src/core/auth/task-deeplink-config.ts

@@ -19,6 +19,8 @@ export interface TaskDeeplinkConfig {
   test: boolean;
   /** 删除接口走假数据（该接口未开发完时打开）。 */
   deleteTest: boolean;
+  /** 行动→任务解析走假数据（xdfx 行动id→任务id）。 */
+  actionTest: boolean;
   /** 目的树查询完整 URL（调用追加 ?taskId=）。 */
   purposeDetailUrl: string;
   /** 删除完整 URL（调用追加 ?taskId=）。 */
@@ -27,10 +29,16 @@ export interface TaskDeeplinkConfig {
   treemapEditUrl: string;
   /** B 系统树形下一步页 URL（跳转追加 ?id=）。 */
   treemapNextUrl: string;
-  /** 测试假数据：purposeDetail = 原始 {state,msg,data}；delete = {message,success}。 */
+  /** 行动详情接口基址（xdfx 行动→任务）：调用追加 /{actionId}，返回 data.taskId 为真正任务id。 */
+  actionDetailUrl: string;
+  /** 「3q详情」详情页 URL（rwfx 目的树面板链接，跳转追加 ?id= 任务id）；留空则前端提示未配置。 */
+  detail3qUrl: string;
+  /** 测试假数据：purposeDetail = 原始 {state,msg,data}；delete = {message,success}；
+   *  actionDetail = 原始 {state,msg,data:{taskId,...}}。 */
   mock: {
     purposeDetail?: unknown;
     delete?: { message?: string; success?: boolean };
+    actionDetail?: unknown;
   };
 }
 
@@ -38,10 +46,13 @@ export interface TaskDeeplinkConfig {
 export const DEFAULT_TASK_DEEPLINK_CONFIG: TaskDeeplinkConfig = {
   test: false,
   deleteTest: false,
+  actionTest: false,
   purposeDetailUrl: "https://ch1.b.uat.4.cn/consumer/taskAnalyseSearch/getTaskPurposeDetail",
   deleteUrl: "https://ch1.b.uat.4.cn/consumer/taskAnalyseSearch/delete",
   treemapEditUrl: "https://ch1.b.uat.4.cn/web/#/task/item-aicoh/step-mode-treemap-full-edit",
   treemapNextUrl: "https://ch1.b.uat.4.cn/web/#/task/item-aicoh/step-mode-treemap-full-next",
+  actionDetailUrl: "https://ch1.b.uat.4.cn/consumer/plan/action",
+  detail3qUrl: "",
   mock: {},
 };
 
@@ -55,16 +66,21 @@ function normalize(body: unknown): TaskDeeplinkConfig {
   return {
     test: o.test === true,
     deleteTest: o.delete_test === true,
+    actionTest: o.action_test === true,
     purposeDetailUrl: str(o.purpose_detail_url, d.purposeDetailUrl),
     deleteUrl: str(o.delete_url, d.deleteUrl),
     treemapEditUrl: str(o.treemap_edit_url, d.treemapEditUrl),
     treemapNextUrl: str(o.treemap_next_url, d.treemapNextUrl),
+    actionDetailUrl: str(o.action_detail_url, d.actionDetailUrl),
+    // detail_3q_url 允许为空（地址待定），不回退默认；只在配了非空时才生效。
+    detail3qUrl: typeof o.detail_3q_url === "string" ? o.detail_3q_url : d.detail3qUrl,
     mock: {
       purposeDetail: mock.purpose_detail,
       delete:
         mock.delete && typeof mock.delete === "object"
           ? (mock.delete as { message?: string; success?: boolean })
           : undefined,
+      actionDetail: mock.action_detail,
     },
   };
 }

frontend-web/src/core/auth/task-deeplink.ts

@@ -17,10 +17,11 @@
 
 import { requestCrudService } from "@/service/request-axios-service";
 import { clearTaskContext, persistTaskContext } from "@/core/auth/task-purpose";
+import { fetchTaskDeeplinkConfig } from "@/core/auth/task-deeplink-config";
 import { listBusinessMappings } from "@/strategy-components/api/business-mapping";
 
-/** rwfx 业务码：单智能体走「任务工作区 + 目的树闸门」（其它业务保持原问答逻辑）。 */
-const RWFX_BUSINESS_CODE = "6BF";
+/** xdfx 业务码：深链传入的是「行动id」，需先调 action 接口解析出真正的「任务id」。 */
+const XDFX_BUSINESS_CODE = "7BF";
 
 /** consumer 接口返回的任务详情（data 字段）。 */
 export interface CopTaskDetail {
@@ -34,6 +35,9 @@ export interface CopTaskDetail {
 /** 任务详情整包暂存的 sessionStorage key（目标页/后续可读取）。 */
 export const COP_TASK_DETAIL_STORAGE_KEY = "login.copTaskDetail";
 
+/** 行动详情整包暂存的 sessionStorage key（xdfx 行动分析：会商/单智能体读取行动名称/叙事）。 */
+export const ACTION_DETAIL_STORAGE_KEY = "login.actionDetail";
+
 /** goPath 基础码 → 业务码（配置管理 businessCode）。 */
 const GOPATH_BUSINESS_CODE: Record<string, string> = {
   "3qfx": "3Q", // 三情分析
@@ -73,8 +77,28 @@ function consumerBaseUrl(): string {
   return typeof value === "string" ? value.replace(/\/+$/, "") : "";
 }
 
-/** 拉取任务详情；缺少 consumer 地址 / 返回不合法时返回 null。 */
+/** cop-task-detail 是否走本地假数据：开关 `VITE_MOCK_COP_TASK_DETAIL=true`（真实接口未就绪时调试用）。 */
+function copTaskDetailMockEnabled(): boolean {
+  return (import.meta.env as Record<string, unknown>).VITE_MOCK_COP_TASK_DETAIL === "true";
+}
+
+/** cop-task-detail 本地假数据（与真实 data 字段同构；mock 开关开启时返回）。 */
+function mockCopTaskDetail(taskId: string): CopTaskDetail {
+  return {
+    id: taskId || "2055",
+    overview: "暑期文旅消费高峰期间的舆情态势综合研判与引导任务（本地假数据）。",
+    taskDirection: "正向引导 + 风险预警",
+    taskName: "任务01：暑期文旅舆情综合研判",
+    taskContent:
+      "围绕暑期文旅消费高峰，对重点城市、重点景区的公众情绪与舆情态势做综合研判，识别情绪拐点与潜在风险，提出正向引导与处置建议。",
+  };
+}
+
+/** 拉取任务详情；``VITE_MOCK_COP_TASK_DETAIL=true`` 走假数据；缺少 consumer 地址 / 返回不合法时返回 null。 */
 export async function fetchCopTaskDetail(taskId: string): Promise<CopTaskDetail | null> {
+  if (copTaskDetailMockEnabled()) {
+    return mockCopTaskDetail(taskId);
+  }
   const base = consumerBaseUrl();
   if (!base || !taskId) return null;
   // service 拦截器已统一注入 `Authorization: Bearer admin` 并返回 response.data（整包 body）。
@@ -110,6 +134,99 @@ export function readCopTaskDetail(): CopTaskDetail | null {
   }
 }
 
+/** 把行动详情整包暂存到 sessionStorage（xdfx 行动分析用；隐私模式/quota 异常时静默失败）。 */
+export function persistActionDetail(detail: ActionDetail): void {
+  try {
+    sessionStorage.setItem(ACTION_DETAIL_STORAGE_KEY, JSON.stringify(detail));
+  } catch {
+    /* noop */
+  }
+}
+
+/** 读取暂存的行动详情（会商左上角「当前行动」、单智能体行动详情卡都可读）。 */
+export function readActionDetail(): ActionDetail | null {
+  try {
+    const raw = sessionStorage.getItem(ACTION_DETAIL_STORAGE_KEY);
+    return raw ? (JSON.parse(raw) as ActionDetail) : null;
+  } catch {
+    return null;
+  }
+}
+
+/** 行动详情接口 ``{action_detail_url}/{actionId}`` 返回的 ``data`` 字段（xdfx 行动分析用）。 */
+export interface ActionDetail {
+  /** 行动id（深链 ?taskId= 传入的就是它）。 */
+  id: string;
+  /** 该行动归属的真正「任务id」。 */
+  taskId: string;
+  /** 所属目的id。 */
+  purposeId: string;
+  /** 行动名称。 */
+  actionName: string;
+  /** 行动状态码。 */
+  actionStatus: number | string;
+  /** 行动叙事 / 描述。 */
+  narration: string;
+}
+
+/**
+ * xdfx 深链：用「行动id」调行动详情接口 ``{action_detail_url}/{actionId}``，取出整包行动详情。
+ * ``action_test=true`` 时直接用后端配置里的假数据（接口未通时用）。
+ * 缺地址 / 返回不合法 → 返回 null。
+ */
+export async function fetchActionDetail(actionId: string): Promise<ActionDetail | null> {
+  if (!actionId) return null;
+  const cfg = await fetchTaskDeeplinkConfig();
+  let body: unknown;
+  if (cfg.actionTest) {
+    body = cfg.mock.actionDetail;
+  } else if (cfg.actionDetailUrl) {
+    const base = cfg.actionDetailUrl.replace(/\/+$/, "");
+    // service 拦截器已统一注入 Authorization: Bearer admin 并返回整包 body；行动id 走路径段。
+    body = await requestCrudService.get(`${base}/${encodeURIComponent(actionId)}`);
+  } else {
+    return null;
+  }
+  const data = body && typeof body === "object" ? (body as { data?: unknown }).data : null;
+  if (!data || typeof data !== "object") return null;
+  const d = data as Record<string, unknown>;
+  const detail: ActionDetail = {
+    id: d.id != null ? String(d.id) : "",
+    taskId: d.taskId != null ? String(d.taskId) : "",
+    purposeId: d.purposeId != null ? String(d.purposeId) : "",
+    actionName: typeof d.actionName === "string" ? d.actionName : "",
+    actionStatus:
+      typeof d.actionStatus === "number" || typeof d.actionStatus === "string" ? d.actionStatus : "",
+    narration: typeof d.narration === "string" ? d.narration : "",
+  };
+  // 取到即整包暂存：登录解析任务id 时(resolveDeeplinkTaskId→fetchTaskIdFromAction)就会缓存它，
+  // 之后会商左上角「当前行动」、单智能体行动详情卡都能直接 readActionDetail()，避免重复请求。
+  persistActionDetail(detail);
+  return detail;
+}
+
+/**
+ * xdfx 深链：用「行动id」解析出真正的「任务id」（取行动详情的 ``data.taskId``）。
+ * 缺地址 / 返回不合法 → 返回 ""（调用方据此回退）。
+ */
+export async function fetchTaskIdFromAction(actionId: string): Promise<string> {
+  return (await fetchActionDetail(actionId))?.taskId ?? "";
+}
+
+/**
+ * 据 goPath 把深链 URL 里的原始 id 解析成真正的「任务id」：
+ *   - xdfx（行动分析）：URL 传入的是「行动id」，调 action 接口换成 ``data.taskId``；
+ *     解析失败返回 ""（让调用方回退默认首页，避免拿行动id当任务id污染后续查询/绑定）。
+ *   - 其它业务：URL 传入的本就是任务id，原样返回。
+ */
+export async function resolveDeeplinkTaskId(goPath: string, rawId: string): Promise<string> {
+  const parsed = parseGoPath(goPath);
+  if (parsed?.businessCode === XDFX_BUSINESS_CODE) {
+    return fetchTaskIdFromAction(rawId);
+  }
+  return rawId;
+}
+
 export interface TaskDeeplinkTarget {
   path: string;
   /** react-router navigate 的 state（多智能体会商用 roundtablePrefill）。 */
@@ -135,25 +252,37 @@ function buildOpeningText(detail: CopTaskDetail, taskId: string): string {
  *     ``sessionStorage.pendingAgentMessage``（AgentChatPage 自动发出）。
  * 无法识别 goPath / 未配置智能体时返回 null（调用方回退到默认首页）。
  *
- * @param taskId 深链 URL 的原始 ``?taskId=``（外部任务 id，用于按任务隔离草稿；与
- *   consumer 返回的 detail.id 区分——后者不保证等于外部任务 id）。
+ * @param taskId 真实任务 id（xdfx 已由 action 接口解析；其它业务即深链原始 ?taskId=）。
+ *   用于按任务隔离草稿/对话；与 consumer 返回的 detail.id 区分。
+ * @param rawId 深链 URL 的原始 ``?taskId=``（xdfx 为「行动id」）。供需追加行动id 的按钮用；
+ *   省略时回退 taskId。
  */
 export async function resolveTaskDeeplinkTarget(
   goPath: string,
   detail: CopTaskDetail,
   taskId: string,
+  rawId?: string,
 ): Promise<TaskDeeplinkTarget | null> {
   const parsed = parseGoPath(goPath);
   if (!parsed) return null;
   const taskBase = BUSINESS_TASK_BASE[parsed.businessCode];
   if (!taskBase) return null;
 
-  // 清掉上一次深链可能残留的任务上下文（仅 rwfx 单智能体会重新写入）。
+  // 清掉上一次深链可能残留的任务上下文（单智能体分支会用本次任务重新写入）。
   clearTaskContext();
 
   if (parsed.roundtable) {
     // 多智能体会商：嵌进对应业务的「任务管理」布局；businessCode 让会商页自动选用配置的业务链条；
     // taskId 让会商页按任务隔离存取草稿（一个 taskId 多条记录），并触发第三步自动结构化输出。
+    // xdfx（行动分析）：根是「行动」——把行动名称随首条消息交给任务理解，左上角展示「当前行动」。
+    // 行动详情登录解析任务id 时已缓存（fetchActionDetail 内 persistActionDetail）；这里优先读缓存。
+    let actionName = "";
+    let actionId = "";
+    if (parsed.businessCode === XDFX_BUSINESS_CODE && rawId) {
+      actionId = rawId;
+      const ad = readActionDetail() ?? (await fetchActionDetail(rawId));
+      actionName = ad?.actionName ?? "";
+    }
     return {
       path: `${taskBase}/roundtable`,
       state: {
@@ -162,6 +291,8 @@ export async function resolveTaskDeeplinkTarget(
           taskGoal: detail.taskContent,
           businessCode: parsed.businessCode,
           taskId: taskId || undefined,
+          ...(actionId ? { actionId } : {}),
+          ...(actionName ? { actionName } : {}),
           autoStart: true,
         },
       },
@@ -177,22 +308,15 @@ export async function resolveTaskDeeplinkTarget(
   }
   if (!agentId) return null;
 
-  if (parsed.businessCode === RWFX_BUSINESS_CODE) {
-    // rwfx：走「任务工作区」——暂存任务上下文（taskId + 开场信息），跳到 chats 索引，
-    // 由工作区按 taskId 决定开最新历史对话 / 新建（新建走目的树闸门）。不设 pendingAgentMessage：
-    // 开场信息在闸门通过后由目的树面板发出。
-    persistTaskContext({ taskId, agentId, openingText: buildOpeningText(detail, taskId) });
-    return { path: `${taskBase}/agent/${agentId}/chats` };
-  }
-
-  // 其它单智能体问答：保持原逻辑（pendingAgentMessage 自动发出 + chats/new）。
-  try {
-    sessionStorage.setItem(
-      "pendingAgentMessage",
-      JSON.stringify({ agentId, text: buildOpeningText(detail, taskId) }),
-    );
-  } catch {
-    /* noop */
-  }
-  return { path: `${taskBase}/agent/${agentId}/chats/new` };
+  // 单智能体问答统一走「任务工作区」（任务↔对话 1:N，按 taskId + agentId 隔离不同业务的对话列表）：
+  // 暂存任务上下文（taskId + agentId + 开场信息），跳到 chats 索引，由工作区按 taskId 决定
+  // 开最新历史对话 / 新建。rwfx 在工作区里额外过「目的树闸门」；3qfx/xdfx 仅 1:N 列表，
+  // 新建对话直接带开场信息自动发出（见 task-purpose / AgentChatPage 的 taskGate / taskBind）。
+  persistTaskContext({
+    taskId,
+    agentId,
+    openingText: buildOpeningText(detail, taskId),
+    actionId: rawId || taskId,
+  });
+  return { path: `${taskBase}/agent/${agentId}/chats` };
 }

frontend-web/src/core/auth/task-purpose.ts

@@ -15,6 +15,12 @@ import {
   getCachedTaskDeeplinkConfig,
 } from "@/core/auth/task-deeplink-config";
 import { requestCrudService } from "@/service/request-axios-service";
+import type {
+  FlowGraphData,
+  FlowGraphEdge,
+  FlowGraphNode,
+  FlowNodeType,
+} from "@/roundtable-planning/lib/flow-graph";
 
 /** 归一化后的目的树节点（用于展示，逐层：目的→行为体→预期行为→驱动因素→叙事）。 */
 export interface PurposeTreeNode {
@@ -33,6 +39,8 @@ export interface TaskContext {
   agentId: string;
   /** 自动发出的开场信息（任务名称/内容）。 */
   openingText: string;
+  /** 深链原始 id（xdfx 为「行动id」，需追加行动id 的按钮用；其它业务等于 taskId）。 */
+  actionId?: string;
 }
 
 const TASK_CONTEXT_STORAGE_KEY = "task.rwfxContext";
@@ -112,6 +120,92 @@ export function flattenPurposeTree(nodes: PurposeTreeNode[]): PurposeFlatCell[][
   return rows;
 }
 
+/* --------------------- 目的树 → 流程图(flow-graph) --------------------- */
+
+/**
+ * 目的树各层级标签 → 流程图节点类型（仅决定配色，见 FLOW_NODE_TYPE_META）。
+ * 未知层级回退 task。层级名本身仍原样写进节点 group，画布上当小标签显示。
+ */
+const PURPOSE_LABEL_TO_FLOW_TYPE: Record<string, FlowNodeType> = {
+  目的: "stage",
+  行为体: "role",
+  预期行为: "task",
+  驱动因素: "decision",
+  叙事: "deliverable",
+};
+
+/** 目的树的一个层级（深度）：层级中文名 + 对应流程图节点类型（决定配色）。 */
+export interface PurposeLevel {
+  /** 层级中文名（目的 / 行为体 / 预期行为 / 驱动因素 / 叙事…）。 */
+  label: string;
+  /** 流程图节点类型（用于取 FLOW_NODE_TYPE_META 配色，与画布节点一致）。 */
+  type: FlowNodeType;
+}
+
+/**
+ * 按**深度**抽出目的树的有序层级（每层取该深度第一个非空层级名作代表）。
+ *
+ * 目的树每一深度的层级是一致的（深度 0 = 目的、1 = 行为体、… 直到叶子叙事），
+ * 故逐层 BFS、每层取一个代表标签即可得到「任务策划共几级、分别是什么」，
+ * 供消息列表上方的「流程示例图」按层级画彩色小图标。
+ */
+export function derivePurposeLevels(tree: PurposeTreeNode[]): PurposeLevel[] {
+  const levels: PurposeLevel[] = [];
+  let frontier = tree;
+  let depth = 0;
+  while (frontier.length > 0 && depth < 12) {
+    const label = frontier.find((n) => n.label?.trim())?.label?.trim() || `层级 ${depth + 1}`;
+    levels.push({ label, type: PURPOSE_LABEL_TO_FLOW_TYPE[label] ?? "task" });
+    frontier = frontier.flatMap((n) => n.children ?? []);
+    depth += 1;
+  }
+  return levels;
+}
+
+/**
+ * 把归一化后的目的树转换成 Step 3 流程图组件（FlowGraphPanel）认识的 FlowGraphData。
+ *
+ * - 逐层深度优先遍历，给每个节点分配稳定 id（`p1/p2/…`，按遍历顺序）；
+ * - 父→子建一条边（from=父 id）；
+ * - 节点主文本(`text`)作 label，层级名(`label`)作 group（画布顶部小标签），
+ *   推荐理由并进 detail（点节点弹窗里看）。
+ * - 传入 ``rootLabel`` 时，在最顶层加一个「任务」根节点，所有「目的」挂到它下面
+ *   （与 B 系统给的「任务 → 目的 → 行为体 → …」流程一致，单一根节点）；不传则保持
+ *   旧的「多个目的各自成根」森林（向后兼容）。
+ * 容错沿用 PurposeTreeNode（normalizeNode 已兜底字段/层级变动），这里不再二次判断。
+ */
+export function purposeTreeToFlowGraph(
+  tree: PurposeTreeNode[],
+  taskId?: string,
+  rootLabel?: string,
+): FlowGraphData {
+  const nodes: FlowGraphNode[] = [];
+  const edges: FlowGraphEdge[] = [];
+  let counter = 0;
+  const walk = (node: PurposeTreeNode, parentId: string | null) => {
+    const id = `p${++counter}`;
+    const type = PURPOSE_LABEL_TO_FLOW_TYPE[node.label] ?? "task";
+    const text = node.text?.trim() || node.label || "（空）";
+    const detail = node.reason?.trim()
+      ? `${text}\n理由：${node.reason.trim()}`
+      : node.text?.trim() || undefined;
+    nodes.push({ id, label: text, type, group: node.label || undefined, detail });
+    if (parentId) edges.push({ from: parentId, to: id });
+    node.children?.forEach((child) => walk(child, id));
+  };
+  // 任务为单一根节点（仅在有目的数据且传入 rootLabel 时）：每个「目的」根挂到它下面。
+  const rootId = rootLabel && rootLabel.trim() && tree.length > 0 ? "task-root" : null;
+  if (rootId) {
+    nodes.push({ id: rootId, label: rootLabel!.trim(), type: "start", group: "任务" });
+  }
+  tree.forEach((root) => walk(root, rootId));
+  return {
+    title: taskId ? `任务目的（任务 ${taskId}）` : "任务目的",
+    nodes,
+    edges,
+  };
+}
+
 /** 从接口/假数据的整包 body 里取出 data 数组并归一化成树。 */
 function bodyToTree(body: unknown): PurposeTreeNode[] {
   const data =
@@ -190,6 +284,12 @@ export function buildTreemapNextUrl(taskId: string): string {
   return url && taskId ? appendQueryParam(url, "id", taskId) : "";
 }
 
+/** 「3q详情」详情页地址（目的树面板链接，新标签打开）；追加 ?id=任务id。地址未配置时返回 ""。 */
+export function buildDetail3qUrl(taskId: string): string {
+  const url = getCachedTaskDeeplinkConfig().detail3qUrl;
+  return url && taskId ? appendQueryParam(url, "id", taskId) : "";
+}
+
 /* --------------------------- 任务上下文暂存 --------------------------- */
 
 export function persistTaskContext(ctx: TaskContext): void {
@@ -210,6 +310,7 @@ export function readTaskContext(): TaskContext | null {
       taskId: String(parsed.taskId),
       agentId: String(parsed.agentId),
       openingText: typeof parsed.openingText === "string" ? parsed.openingText : "",
+      actionId: typeof parsed.actionId === "string" ? parsed.actionId : undefined,
     };
   } catch {
     return null;

frontend-web/src/core/auth/wujie-ticket-login.ts

@@ -4,6 +4,7 @@ import {
   EXTERNAL_LOGIN_STORAGE_KEYS,
   persistExternalLoginParams,
 } from "./external-login";
+import { authStorageSet } from "@/core/auth/scoped-storage";
 
 const AUTH_BASE_URL = (import.meta.env.VITE_AUTH_BASE_URL || "").replace(
   /\/$/,
@@ -49,21 +50,14 @@ type UserDetailTokenResponse = {
 };
 
 function persistMaxkeyOnlineToken(token: string): void {
-  try {
-    localStorage.setItem(MAXKEY_ONLINE_TOKEN_STORAGE_KEY, token);
-  } catch {
-    // 静默失败，不阻断登录
-  }
+  // 嵌入(iframe)态走 sessionStorage（按标签页隔离），正常态走 localStorage。
+  authStorageSet(MAXKEY_ONLINE_TOKEN_STORAGE_KEY, token);
 }
 
 function persistUserDetailToken(data: UserDetailTokenPayload): void {
-  try {
-    localStorage.setItem(USER_DETAIL_TOKEN_STORAGE_KEY, JSON.stringify(data));
-    if (data.user_id) {
-      localStorage.setItem(EXTERNAL_LOGIN_STORAGE_KEYS.userId, String(data.user_id));
-    }
-  } catch {
-    // 静默失败
+  authStorageSet(USER_DETAIL_TOKEN_STORAGE_KEY, JSON.stringify(data));
+  if (data.user_id) {
+    authStorageSet(EXTERNAL_LOGIN_STORAGE_KEYS.userId, String(data.user_id));
   }
 }
 

frontend-web/src/core/auth/yuser-login.ts

@@ -1,4 +1,5 @@
 import { requestCrudService } from "@/service/request-axios-service";
+import { authStorageGet, authStorageSet } from "@/core/auth/scoped-storage";
 
 const CONSUMER_URL = import.meta.env.VITE_AIPI_CONSUMER_URL || "";
 
@@ -23,7 +24,7 @@ export async function loginByYUserId(
   token?: string | null,
 ): Promise<void> {
   if (token) {
-    localStorage.setItem(TOOLS_TOKEN_STORAGE_KEY, token);
+    authStorageSet(TOOLS_TOKEN_STORAGE_KEY, token);
   }
 
   const res = (await requestCrudService.get(
@@ -37,14 +38,14 @@ export async function loginByYUserId(
   // 注意:接口也会返回 accessToken,但 XK/PG 及 source=accessToken 要用路由透传的
   // access_token,故登录流程随后会用 persistAccessToken 覆盖 userInfo.accessToken。
   const result = res.data ?? {};
-  localStorage.setItem(
+  authStorageSet(
     EXTERNAL_USER_INFO_STORAGE_KEY,
     JSON.stringify({ ...result, yUserId }),
   );
 }
 
 export function persistToolsToken(token: string): void {
-  localStorage.setItem(TOOLS_TOKEN_STORAGE_KEY, token);
+  authStorageSet(TOOLS_TOKEN_STORAGE_KEY, token);
 }
 
 /**
@@ -59,7 +60,7 @@ export function persistAccessToken(token: string): void {
   if (!trimmed) return;
   let info: Record<string, unknown> = {};
   try {
-    const raw = localStorage.getItem(EXTERNAL_USER_INFO_STORAGE_KEY);
+    const raw = authStorageGet(EXTERNAL_USER_INFO_STORAGE_KEY);
     if (raw) {
       const parsed = JSON.parse(raw);
       if (parsed && typeof parsed === "object") {
@@ -70,5 +71,5 @@ export function persistAccessToken(token: string): void {
     info = {};
   }
   info.accessToken = trimmed;
-  localStorage.setItem(EXTERNAL_USER_INFO_STORAGE_KEY, JSON.stringify(info));
+  authStorageSet(EXTERNAL_USER_INFO_STORAGE_KEY, JSON.stringify(info));
 }

frontend-web/src/core/embed/embed-session.ts

@@ -0,0 +1,213 @@
+/**
+ * 「外部系统 iframe 套用深链」相关的**按标签页**会话开关。承载三个相互独立的能力，多由 URL
+ * 路由参数开启（独立会话 `isolate` 另可由「外观」设置里的开关在运行时切换，见 `setIsolatedSession`），
+ * 存进同一份 sessionStorage 会话、跨登录跳转/刷新/页内导航存活：
+ *
+ *   1. `embed=1`（可带 `&theme=`）—— **嵌入模式**：去掉全局导航栏（Header）+ 侧边栏（PageSidebar），
+ *      并按外部主题色强制系统明/暗（离散切换）。
+ *   2. `hideJump=1` —— **隐藏深链底部「快捷跳转」栏**：去掉 `TaskJumpBar` 的两部分——底部的
+ *      「下一步」等按钮 + 右侧垂直居中的悬浮菜单（单智能体问答 / 多智能体会商深链共用该栏）。
+ *   3. `isolate=1` —— **独立会话登录**：本标签页的鉴权身份按标签页隔离（见 [[scoped-storage]]
+ *      `authStorage()`，嵌入态与独立态同走 sessionStorage）。用于同一浏览器里**另开一个标签页登
+ *      录不同账号**而**不覆盖**当前标签页（localStorage）的登录态——`embed` 已隐含此隔离，`isolate`
+ *      则是把同一套隔离单独提供给**普通（带 chrome）标签页**，不去 chrome、不强制主题、不动跳转栏。
+ *
+ * 三者可单独使用，也可叠加：`hideJump` **只**隐藏跳转栏，不动 chrome / 主题；`embed` 不影响跳转栏；
+ * `isolate` 只切换鉴权存储，不影响 chrome / 主题 / 跳转栏。
+ *
+ * 隔离要点（核心诉求：同一浏览器另开咱们正常系统页，**绝不能**被这些开关影响）：
+ *   - 用 **sessionStorage**（按标签页隔离、绝不跨标签）持有这些 flag，而**不用** localStorage
+ *     （跨标签共享 → 会污染正常页）。
+ *   - 主题走 next-themes 的 `forcedTheme`（见 App.tsx `AppProviders`）——只在本标签页生效、
+ *     不写 localStorage `strategy-theme`；嵌入侧绝不调 `setTheme`。
+ *   - 去 chrome / 去跳转栏均由本模块的 sessionStorage flag 驱动，不碰 `persistSidebarEnabled` 等
+ *     localStorage 偏好。
+ *
+ * iframe 的浏览器上下文就是它自己的标签页，sessionStorage 天然「一个 iframe 一份、随关闭消失」；
+ * 正常页标签页里既无这些参数也无这份会话 → 所有 `isXxx()` 恒为 false，完全不受影响。
+ */
+
+const EMBED_SESSION_KEY = "embed.session";
+
+export type EmbedTheme = "light" | "dark";
+
+/** 本标签页的嵌入会话（按需置位的若干独立开关）。 */
+export interface EmbedSession {
+  /** 嵌入模式：去全局 chrome + 强制主题。 */
+  embed: boolean;
+  /** 嵌入模式下强制的主题（仅 embed 为真时有意义）。 */
+  theme: EmbedTheme;
+  /** 隐藏深链底部「快捷跳转」栏（TaskJumpBar：底部按钮 + 右侧悬浮菜单）。 */
+  hideJump: boolean;
+  /** 独立会话：鉴权身份按本标签页隔离（走 sessionStorage），用于同浏览器登录不同账号互不覆盖。 */
+  isolate: boolean;
+}
+
+/** URL 布尔参数的三态：显式开 / 显式关 / 未带。 */
+type FlagParam = "on" | "off" | null;
+
+function toSearchParams(search: string): URLSearchParams {
+  return new URLSearchParams(search.startsWith("?") ? search : `?${search}`);
+}
+
+/** 读某个布尔型 query 参数的三态。`1/true/yes` → on；`0/false/no` → off；缺省/其它 → null。 */
+function readFlagParam(search: string, key: string): FlagParam {
+  const v = (toSearchParams(search).get(key) ?? "").trim().toLowerCase();
+  if (!v) return null;
+  if (v === "1" || v === "true" || v === "yes") return "on";
+  if (v === "0" || v === "false" || v === "no") return "off";
+  return null;
+}
+
+/** 读 URL 里的 `embed` 三态。 */
+export function readEmbedParam(search: string): FlagParam {
+  return readFlagParam(search, "embed");
+}
+
+/** 读 URL 里的 `hideJump` 三态。 */
+export function readHideJumpParam(search: string): FlagParam {
+  return readFlagParam(search, "hideJump");
+}
+
+/** 读 URL 里的 `isolate` 三态（独立会话登录）。 */
+export function readIsolateParam(search: string): FlagParam {
+  return readFlagParam(search, "isolate");
+}
+
+/**
+ * 把外部传入的主题色映射成离散明/暗。与 `resolveThemeFromQuery` 同源约定（dark-blue → 深色），
+ * 另外宽松接受 `dark` / 中文「深色/深蓝」直传；其余（含空）一律浅色。
+ */
+export function resolveEmbedThemeMode(raw: string | null | undefined): EmbedTheme {
+  const v = (raw ?? "").trim().toLowerCase();
+  if (v === "dark" || v === "dark-blue" || v === "深色" || v === "深蓝") return "dark";
+  return "light";
+}
+
+/** 取 URL query 里的 `theme` 值（embed 主题来源）。 */
+export function readEmbedThemeParam(search: string): string {
+  return (toSearchParams(search).get("theme") ?? "").trim();
+}
+
+/** 读本标签页的嵌入会话；无 → null。 */
+export function readEmbedSession(): EmbedSession | null {
+  try {
+    const raw = sessionStorage.getItem(EMBED_SESSION_KEY);
+    if (!raw) return null;
+    const p = JSON.parse(raw) as Partial<EmbedSession>;
+    return {
+      embed: p.embed === true,
+      theme: p.theme === "dark" ? "dark" : "light",
+      hideJump: p.hideJump === true,
+      isolate: p.isolate === true,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** 写会话；无任何开关置位时直接清除（保持 sessionStorage 干净）。隐私模式/quota 异常静默失败。 */
+function writeEmbedSession(next: EmbedSession): void {
+  try {
+    if (!next.embed && !next.hideJump && !next.isolate) {
+      sessionStorage.removeItem(EMBED_SESSION_KEY);
+      return;
+    }
+    sessionStorage.setItem(EMBED_SESSION_KEY, JSON.stringify(next));
+  } catch {
+    /* noop */
+  }
+}
+
+/** 本标签页是否处于嵌入模式（驱动去全局 chrome + 强制主题）。 */
+export function isEmbedActive(): boolean {
+  return readEmbedSession()?.embed === true;
+}
+
+/** 本标签页是否要隐藏深链底部「快捷跳转」栏（TaskJumpBar）。 */
+export function isJumpBarHidden(): boolean {
+  return readEmbedSession()?.hideJump === true;
+}
+
+/**
+ * 本标签页是否处于独立会话态：鉴权身份按标签页隔离（走 sessionStorage）。
+ * `embed` 已隐含同样的隔离，故 `authStorage()` 取「embed || isolate」之并；这里只判 `isolate`，
+ * 供需要区分「纯独立会话（带 chrome）」与「嵌入态（去 chrome）」的场合使用。
+ */
+export function isIsolatedSession(): boolean {
+  return readEmbedSession()?.isolate === true;
+}
+
+/**
+ * 按 URL 参数同步 sessionStorage 会话（AppProviders 在每次 search 变化时调用一次）。
+ * **合并语义**：on 置位、off 清位、未带则沿用既有值——这样登录后跳到不带参数的干净路由时，
+ * 之前置位的开关不会被抹掉。
+ */
+export function syncEmbedSessionFromSearch(search: string): void {
+  const cur =
+    readEmbedSession() ??
+    { embed: false, theme: "light" as EmbedTheme, hideJump: false, isolate: false };
+  const next: EmbedSession = { ...cur };
+
+  const embedParam = readEmbedParam(search);
+  if (embedParam === "on") {
+    next.embed = true;
+    next.theme = resolveEmbedThemeMode(readEmbedThemeParam(search));
+  } else if (embedParam === "off") {
+    next.embed = false;
+  }
+
+  const hideJumpParam = readHideJumpParam(search);
+  if (hideJumpParam === "on") next.hideJump = true;
+  else if (hideJumpParam === "off") next.hideJump = false;
+
+  const isolateParam = readIsolateParam(search);
+  if (isolateParam === "on") next.isolate = true;
+  else if (isolateParam === "off") next.isolate = false;
+
+  writeEmbedSession(next);
+}
+
+/**
+ * 从当前 HashRouter URL（`#/path?a=b`）取出 query 串。
+ * 供「在 React 渲染之前」同步启用嵌入会话（main.tsx）——必须早于任何鉴权写入，
+ * 否则首帧 LoginPage 的 effect 可能抢在 AppProviders 同步 effect 之前把登录参数写进 localStorage。
+ */
+function currentHashSearch(): string {
+  if (typeof window === "undefined") return "";
+  const hash = window.location.hash || "";
+  const i = hash.indexOf("?");
+  return i >= 0 ? hash.slice(i) : "";
+}
+
+/** main.tsx 在渲染前同步调用一次：据当前 URL 启用/关闭本标签页嵌入会话。 */
+export function syncEmbedSessionFromCurrentUrl(): void {
+  syncEmbedSessionFromSearch(currentHashSearch());
+}
+
+/**
+ * 解析「应当强制的嵌入主题」供 `AppProviders` 的 `forcedTheme` 用：
+ *   - URL 显式 `embed=1` → 用 URL `theme`（首帧即生效，登录页转场不闪烁）；
+ *   - URL 显式 `embed=0` → 不强制（undefined）；
+ *   - URL 未带 → 回退本标签页嵌入会话主题（仅 embed 置位时）。
+ * 非嵌入标签页恒返回 undefined → 完全不影响正常系统页的主题。
+ */
+export function resolveForcedEmbedTheme(search: string): EmbedTheme | undefined {
+  const param = readEmbedParam(search);
+  if (param === "on") return resolveEmbedThemeMode(readEmbedThemeParam(search));
+  if (param === "off") return undefined;
+  const session = readEmbedSession();
+  return session?.embed ? session.theme : undefined;
+}
+
+/**
+ * 运行时直接置位/清除本标签页的独立会话标志（供「外观」设置里的开关用，区别于 URL 参数驱动）。
+ * 仅切换标志；登录态的「localStorage 快照搬进 sessionStorage」由 [[scoped-storage]]
+ * `migrateAuthToSession()` 负责，调用顺序见 appearance 设置页。
+ */
+export function setIsolatedSession(on: boolean): void {
+  const cur =
+    readEmbedSession() ??
+    { embed: false, theme: "light" as EmbedTheme, hideJump: false, isolate: false };
+  writeEmbedSession({ ...cur, isolate: on });
+}

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

@@ -65,6 +65,12 @@ export const sidebarMenuItems: MenuItem[] = [
         icon: Users,
         path: "/page/strategy/qa/multi-agent-roundtable",
       },
+      {
+        id: "dashboard-agent",
+        label: "大屏绘制",
+        icon: Gauge,
+        path: "/page/strategy/dashboard-agent",
+      },
       // { id: "expert-qa", label: "专家问答", icon: Brain, path: "/page/strategy/qa/expert-qa" },
       {
         id: "qa-zzjc",

frontend-web/src/core/strategy/external-links.ts

@@ -1,5 +1,7 @@
 /** Strategy 模块外部 iframe / 嵌入页链接（来自 Vite 环境变量） */
 
+import { authStorageGet } from "@/core/auth/scoped-storage";
+
 function trimTrailingSlash(url: string): string {
   return url.replace(/\/+$/, "");
 }
@@ -30,7 +32,7 @@ export function getNetworkActorIframeUrl(): string {
 /** 读取并解析 localStorage 中的 userInfo（登录信息）。 */
 function readUserInfo(): Record<string, unknown> {
   try {
-    const raw = localStorage.getItem("userInfo");
+    const raw = authStorageGet("userInfo");
     if (!raw) return {};
     const parsed = JSON.parse(raw);
     return parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : {};

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

@@ -785,7 +785,10 @@ export function useThreadStream({
         } as typeof thread)
       : thread;
 
-  return [mergedThread, sendMessage, isUploading] as const;
+  // 第 4 个返回值 `onStreamThreadId` = 底层 useStream 当前实际绑定的线程 id（新建/未保存时为 null）。
+  // 调用方据此判断「流是否已切到全新线程」，避免在切换会话的那一帧把消息发进上一个会话
+  // （submit 的 threadId 选项仅在 hook 线程为 null/undefined 时才生效）。
+  return [mergedThread, sendMessage, isUploading, onStreamThreadId] as const;
 }
 
 export function useThreads(

frontend-web/src/core/threads/thread-access-error.ts

@@ -0,0 +1,98 @@
+import { toast } from "sonner";
+
+import { getStoredAuth } from "@/core/auth";
+
+/**
+ * Shared helpers for re-framing LangGraph "thread not accessible" 404s around
+ * the current login identity.
+ *
+ * The most common cause in practice is a login session change: a thread is
+ * owned by the previously logged-in account, so after switching accounts the
+ * backend (``app/gateway/authz.py``) correctly returns
+ * ``HTTP 404: {"detail":"Thread <uuid> not accessible"}``. Raw-toasting that
+ * 404 just leaves the user staring at a scary error. Both the chat stream
+ * (``core/threads/hooks.ts``) and the AI-writing stream
+ * (``open-canvas/contexts/AIWritingContext.tsx``) funnel their stream errors
+ * through here so the UX is identical: detect the login-change 404 and prompt
+ * the user to refresh against the current identity instead of erroring out.
+ */
+
+/** Normalize an unknown stream error into a human-readable message string. */
+export function getStreamErrorMessage(error: unknown): string {
+  if (typeof error === "string" && error.trim()) {
+    return error;
+  }
+  if (error instanceof Error && error.message.trim()) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null) {
+    const message = Reflect.get(error, "message");
+    if (typeof message === "string" && message.trim()) {
+      return message;
+    }
+    const nestedError = Reflect.get(error, "error");
+    if (nestedError instanceof Error && nestedError.message.trim()) {
+      return nestedError.message;
+    }
+    if (typeof nestedError === "string" && nestedError.trim()) {
+      return nestedError;
+    }
+  }
+  return "Request failed.";
+}
+
+/**
+ * Detect "thread not found" / forbidden errors from the LangGraph SDK.
+ *
+ * Backend returns 404 both when a thread truly doesn't exist and when the
+ * currently authenticated user doesn't own it ("not found" = no row + no
+ * checkpoint, "not accessible" = row owned by another user / stale login
+ * session). Both mean the current user can't use this thread.
+ */
+export function isThreadNotAccessibleError(message: string): boolean {
+  const lowered = message.toLowerCase();
+  if (/thread\s+[\w-]{8,}\s+not\s+(found|accessible)/i.test(message)) {
+    return true;
+  }
+  // Fallback: a bare 404/403 from the threads endpoint when the SDK has
+  // wrapped the detail differently.
+  return (
+    (lowered.includes("http 404") || lowered.includes("http 403")) &&
+    lowered.includes("thread")
+  );
+}
+
+/** Build a label for the *current* logged-in identity (email → user_id → 未知). */
+export function buildCurrentUserLabel(): string {
+  const auth = getStoredAuth();
+  if (!auth) {
+    return "未登录";
+  }
+  const email = auth.email?.trim();
+  if (email) {
+    return email;
+  }
+  const userId = auth.user_id?.trim();
+  return userId ? userId : "未知用户";
+}
+
+/**
+ * Re-frame a login-change 404 around the current identity and reload the page.
+ *
+ * Shows a friendly toast naming the current login, then full-reloads after a
+ * short delay so the toast is visible and so TanStack Query cache / context
+ * providers / any state captured under the previous user get rebuilt against
+ * the current login. Used by streams whose session id lives in component state
+ * (not the URL) — a plain reload lands them back on a fresh, valid page.
+ */
+export function notifyThreadAccessChangedAndReload(): void {
+  const userLabel = buildCurrentUserLabel();
+  toast.info(
+    `当前登录用户为 ${userLabel}，原会话不存在或无权访问，正在为你刷新页面…`,
+  );
+  if (typeof window !== "undefined") {
+    window.setTimeout(() => {
+      window.location.reload();
+    }, 900);
+  }
+}

frontend-web/src/core/threads/use-task-threads.ts

@@ -4,19 +4,27 @@
  * 新建对话时由 [[task-purpose]] 流程给 thread 打 ``metadata.taskId`` 标签
  * （见 useThreadStream 的 ``threadMetadata``）；这里复用服务端分页搜索按该标签过滤，
  * 后端默认按 ``updated_at desc`` 排序，所以 ``threads[0]`` 即最新一条。
+ *
+ * 同一个 taskId 可能挂在多条业务链上（rwfx / 3qfx / xdfx 共用任务 id），每条业务用各自的
+ * 智能体。传入 ``agentId`` 时额外按 ``metadata.agent_id`` 过滤（后端 metadata 过滤是 AND/子集
+ * 匹配），把不同业务的对话列表隔离开——否则三种业务的对话会混在一起。
  */
 
 import { useThreadsPage } from "@/core/threads/hooks";
 import type { AgentThread } from "@/core/threads/types";
 
-export function useTaskThreads(taskId: string | null | undefined) {
+export function useTaskThreads(
+  taskId: string | null | undefined,
+  agentId?: string | null | undefined,
+) {
   const enabled = !!taskId;
   // 任务工作区只在有 taskId 时渲染；无 taskId 时传一个不可能命中的过滤，返回空列表。
-  const query = useThreadsPage({
-    page: 1,
-    pageSize: 100,
-    metadata: enabled ? { taskId } : { taskId: "__none__" },
-  });
+  const metadata = enabled
+    ? agentId
+      ? { taskId, agent_id: agentId }
+      : { taskId }
+    : { taskId: "__none__" };
+  const query = useThreadsPage({ page: 1, pageSize: 100, metadata });
   const threads: AgentThread[] = enabled ? (query.data?.threads ?? []) : [];
   return {
     ...query,

frontend-web/src/lib/desensitize.ts

@@ -11,6 +11,10 @@
  * {@link DESENSITIZE_MAP}。
  */
 export const SEED_DESENSITIZE_MAP: Readonly<Record<string, string>> = Object.freeze({
+  // 任务工作区业务名 → 业务码（脱敏展示）。整词在前，优先于下面更短的「任务」「行动」匹配。
+  任务分析: "rwfx",
+  三情分析: "3qfx",
+  行动分析: "xdfx",
   方案: "FA",
   设计: "SJ",
   任务: "RW", 

frontend-web/src/main.tsx

@@ -1,15 +1,20 @@
-import "@fontsource/noto-sans-sc/chinese-simplified-400.css";
-import "@fontsource/noto-sans-sc/chinese-simplified-500.css";
-import "@fontsource/noto-sans-sc/chinese-simplified-600.css";
-import "@fontsource/noto-sans-sc/chinese-simplified-700.css";
-import "./styles/globals.css";
-import "tdesign-react/es/style/index.css";
-import "katex/dist/katex.min.css";
+import "@fontsource/noto-sans-sc/chinese-simplified-400.css";
+import "@fontsource/noto-sans-sc/chinese-simplified-500.css";
+import "@fontsource/noto-sans-sc/chinese-simplified-600.css";
+import "@fontsource/noto-sans-sc/chinese-simplified-700.css";
+import "./styles/globals.css";
+import "tdesign-react/es/style/index.css";
+import "katex/dist/katex.min.css";
 
 import React from "react";
 import ReactDOM from "react-dom/client";
 
 import { App } from "./App";
+import { syncEmbedSessionFromCurrentUrl } from "@/core/embed/embed-session";
+
+// 渲染前同步启用「iframe 嵌入会话」（按标签页 sessionStorage）：必须早于任何鉴权写入，
+// 使 iframe 嵌入态的登录走 sessionStorage、与同浏览器正常登录（localStorage）完全隔离。
+syncEmbedSessionFromCurrentUrl();
 
 ReactDOM.createRoot(document.getElementById("root")!).render(
   <React.StrictMode>

frontend-web/src/open-canvas/api/ai-writing-sessions.ts

@@ -87,6 +87,50 @@ export async function deleteAIWritingSession(id: string): Promise<void> {
   if (!resp.ok) throw new Error(`删除失败: ${resp.status}`);
 }
 
+/**
+ * 把一篇写作转入「后台挂起」：后端自动驱动剩余流程到定稿（离页/刷新/切号不打断）。
+ *
+ * 幂等——同一会话已在后台跑则后端直接返回 ``started:false``。
+ */
+export async function suspendAIWritingToBackground(
+  id: string,
+): Promise<{ started: boolean; status: string }> {
+  const resp = await apiFetch(`${BASE()}/${id}/background`, { method: 'POST' });
+  if (!resp.ok) throw new Error(`后台挂起失败: ${resp.status}`);
+  return resp.json();
+}
+
+/** 一篇写作的实际进度（供「查看进度」流程图弹窗轮询）。 */
+export interface AIWritingProgress {
+  sessionStatus: string;
+  /** 规范化阶段 key（与流程图阶段一一对应）；null = 还没建 checkpoint。 */
+  stage: string | null;
+  note: string | null;
+  revisionCount: number;
+  maxRevisions: number;
+  reviewVerdict: string | null;
+  isRunning: boolean;
+}
+
+export async function getAIWritingProgress(id: string): Promise<AIWritingProgress> {
+  const resp = await apiFetch(`${BASE()}/${id}/progress`);
+  if (!resp.ok) throw new Error(`获取进度失败: ${resp.status}`);
+  return resp.json();
+}
+
+/**
+ * beforeunload 兜底：离开/刷新页面时用 keepalive 发起后台挂起，
+ * 保证浏览器卸载页面后请求仍能发完。fire-and-forget，不读响应；
+ * 重复触发由后端「同会话已在后台跑」幂等兜住。
+ */
+export function suspendAIWritingToBackgroundKeepalive(id: string): void {
+  try {
+    void apiFetch(`${BASE()}/${id}/background`, { method: 'POST', keepalive: true }).catch(() => {});
+  } catch {
+    /* 卸载阶段尽力而为，忽略一切异常 */
+  }
+}
+
 /**
  * 保存会话的完整对话时间线，供历史回显出与实时对话一致的富时间线。
  *

frontend-web/src/open-canvas/components/ai-writing/AIWritingFlowChart.tsx

@@ -0,0 +1,138 @@
+/**
+ * AI 写作流程图（竖向固定流水线）。
+ *
+ * 写作流程是固定线性流水线：意图理解 → 素材搜集 → 素材确认 → 大纲规划 → 大纲确认 →
+ * 写作 → 草稿确认 → 编辑审核 → 定稿。按传入的 ``activeKey``（后端从 graph checkpoint
+ * 推导的当前阶段 key）点亮：已过=done 打钩、当前=active 转圈、未到=灰。
+ *
+ * 纯展示组件，无弹窗/无窗口 chrome —— 由 ``AIWritingFlowDialog`` 套在弹窗里使用。
+ */
+import { CheckIcon, Loader2Icon } from 'lucide-react';
+
+import { cn } from '@/lib/utils';
+
+export interface FlowStage {
+  key: string;
+  label: string;
+  emoji: string;
+}
+
+/** 固定流水线阶段（key 与后端 ai_writing_job_executor 的 stage key 一致）。 */
+export const FLOW_STAGES: readonly FlowStage[] = [
+  { key: 'intent', label: '意图理解', emoji: '🧭' },
+  { key: 'research', label: '素材搜集', emoji: '🔍' },
+  { key: 'material_confirm', label: '素材确认', emoji: '📚' },
+  { key: 'outline', label: '大纲规划', emoji: '🗂️' },
+  { key: 'outline_confirm', label: '大纲确认', emoji: '🧩' },
+  { key: 'draft', label: '写作', emoji: '✍️' },
+  { key: 'draft_confirm', label: '草稿确认', emoji: '📝' },
+  { key: 'review', label: '编辑审核', emoji: '🧐' },
+  { key: 'done', label: '定稿', emoji: '🏁' },
+];
+
+export const FLOW_STAGE_LABEL: Record<string, string> = Object.fromEntries(
+  FLOW_STAGES.map((s) => [s.key, s.label]),
+);
+
+type StageState = 'pending' | 'active' | 'done' | 'error';
+
+const LINE = 'bg-slate-300 dark:bg-border';
+
+function StageNode({
+  label,
+  emoji,
+  state,
+  note,
+}: {
+  label: string;
+  emoji: string;
+  state: StageState;
+  note?: string | null;
+}) {
+  return (
+    <div className="flex shrink-0 flex-col items-center gap-1 px-0.5 text-center">
+      <div className="relative flex size-11 items-center justify-center">
+        {state === 'active' && <span className="absolute inset-0 animate-ping rounded-full bg-primary/25" />}
+        <span
+          className={cn(
+            'relative flex size-11 items-center justify-center rounded-full border-2 bg-white text-lg transition-all dark:bg-card',
+            state === 'active' && 'border-primary shadow-[0_0_0_3px_rgba(22,119,255,0.12)]',
+            state === 'done' && 'border-emerald-400/70',
+            state === 'error' && 'border-destructive',
+            state === 'pending' && 'border-border opacity-45 grayscale',
+          )}
+        >
+          {emoji}
+          {state === 'done' && (
+            <span className="absolute -right-0.5 -top-0.5 flex size-4 items-center justify-center rounded-full bg-emerald-500 text-white shadow">
+              <CheckIcon className="size-2.5" />
+            </span>
+          )}
+          {state === 'active' && (
+            <span className="absolute -right-0.5 -top-0.5 flex size-4 items-center justify-center rounded-full bg-primary text-primary-foreground shadow">
+              <Loader2Icon className="size-2.5 animate-spin" />
+            </span>
+          )}
+        </span>
+      </div>
+      <span
+        className={cn(
+          'whitespace-nowrap rounded border px-1 py-px text-[10px] font-medium leading-tight',
+          state === 'active' && 'border-primary/40 bg-primary/10 text-primary',
+          state === 'done' && 'border-emerald-400/40 bg-emerald-50 text-emerald-600 dark:bg-emerald-950/30',
+          state === 'error' && 'border-destructive/40 bg-destructive/10 text-destructive',
+          state === 'pending' && 'border-border bg-muted text-muted-foreground',
+        )}
+        title={label}
+      >
+        {label}
+      </span>
+      {note && state === 'active' && (
+        <span className="rounded bg-amber-100 px-1 py-px text-[9px] font-medium text-amber-600 dark:bg-amber-950/30">
+          {note}
+        </span>
+      )}
+    </div>
+  );
+}
+
+export function AIWritingFlowChart({
+  activeKey,
+  isError = false,
+  note,
+  className,
+}: {
+  /** 当前阶段 key（null = 还没开始 / 准备中，全部置灰）。 */
+  activeKey: string | null;
+  isError?: boolean;
+  note?: string | null;
+  className?: string;
+}) {
+  const allDone = activeKey === 'done';
+  const activeIdx = activeKey ? FLOW_STAGES.findIndex((s) => s.key === activeKey) : -1;
+  const stateOf = (idx: number): StageState => {
+    if (allDone) return 'done';
+    if (activeIdx < 0) return 'pending';
+    if (idx < activeIdx) return 'done';
+    if (idx === activeIdx) return isError ? 'error' : 'active';
+    return 'pending';
+  };
+
+  return (
+    // 横向流水线：左→右排列，节点间用横向连线（对齐到圆形头像竖直中心 ≈ 22px）。
+    // w-max 保持内容固有宽度，由外层 overflow-x-auto 在放不下时横向滚动。
+    <div className={cn('flex w-max flex-row items-start', className)}>
+      {FLOW_STAGES.map((stage, idx) => (
+        <div className="contents" key={stage.key}>
+          {idx > 0 && <div className={cn('mt-[22px] h-px w-5 shrink-0', LINE)} />}
+          <StageNode
+            label={stage.label}
+            emoji={stage.emoji}
+            state={stateOf(idx)}
+            note={stage.key === activeKey ? note : undefined}
+          />
+        </div>
+      ))}
+    </div>
+  );
+}

frontend-web/src/open-canvas/components/ai-writing/AIWritingFlowDialog.tsx

@@ -0,0 +1,124 @@
+/**
+ * 「查看进度」流程图弹窗。
+ *
+ * 在历史记录里点击一条**后台挂起中**的写作 → 弹出本弹窗，里面是写作流程图，
+ * 实时（轮询）反映该会话后端的实际推进位置，让用户看到「跑到哪一步了」。
+ */
+import { useEffect, useRef, useState } from 'react';
+import { Loader2 } from 'lucide-react';
+
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+
+import {
+  getAIWritingProgress,
+  type AIWritingProgress,
+  type AIWritingSessionSummary,
+} from '../../api/ai-writing-sessions';
+import { AIWritingFlowChart, FLOW_STAGE_LABEL } from './AIWritingFlowChart';
+
+const POLL_MS = 2500;
+
+function isTerminal(p: AIWritingProgress | null): boolean {
+  if (!p) return false;
+  return p.sessionStatus === 'done' || p.sessionStatus === 'error' || p.stage === 'done';
+}
+
+export function AIWritingFlowDialog({
+  session,
+  open,
+  onOpenChange,
+}: {
+  session: AIWritingSessionSummary | null;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+}) {
+  const [progress, setProgress] = useState<AIWritingProgress | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [fetchError, setFetchError] = useState(false);
+  const timerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+
+  useEffect(() => {
+    if (!open || !session) return;
+    let cancelled = false;
+    setProgress(null);
+    setFetchError(false);
+    setLoading(true);
+
+    const tick = async () => {
+      try {
+        const p = await getAIWritingProgress(session.id);
+        if (cancelled) return;
+        setProgress(p);
+        setFetchError(false);
+        setLoading(false);
+        // 终态停止轮询，否则继续。
+        if (!isTerminal(p)) {
+          timerRef.current = setTimeout(tick, POLL_MS);
+        }
+      } catch {
+        if (cancelled) return;
+        setFetchError(true);
+        setLoading(false);
+        timerRef.current = setTimeout(tick, POLL_MS);
+      }
+    };
+    void tick();
+
+    return () => {
+      cancelled = true;
+      if (timerRef.current) clearTimeout(timerRef.current);
+      timerRef.current = null;
+    };
+  }, [open, session]);
+
+  const terminal = isTerminal(progress);
+  const isError = progress?.sessionStatus === 'error';
+  const stage = progress?.stage ?? null;
+
+  let caption: string;
+  if (loading && !progress) {
+    caption = '加载进度中…';
+  } else if (isError) {
+    caption = '后台执行出错，请重新发起写作';
+  } else if (progress?.sessionStatus === 'done' || stage === 'done') {
+    caption = '✓ 写作已完成，点开这条记录即可查看成稿';
+  } else {
+    const stageLabel = stage ? (FLOW_STAGE_LABEL[stage] ?? '准备中') : '准备中';
+    let text = `后台运行中 · 当前：${stageLabel}`;
+    if (progress?.note) text += `（${progress.note}）`;
+    if (stage === 'review' && (progress?.revisionCount ?? 0) > 0) {
+      text += ` · 第 ${progress!.revisionCount}/${progress!.maxRevisions} 轮修改`;
+    }
+    caption = text;
+  }
+
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent className="sm:max-w-2xl">
+        <DialogHeader>
+          <DialogTitle className="truncate pr-6 text-sm" title={session?.title}>
+            写作进度 · {session?.draft_title || session?.title || '后台写作'}
+          </DialogTitle>
+        </DialogHeader>
+
+        <div className="flex flex-col items-center gap-3 py-1">
+          <div className="w-full overflow-x-auto py-2">
+            <AIWritingFlowChart className="mx-auto" activeKey={stage} isError={isError} note={progress?.note} />
+          </div>
+
+          <div className="flex items-center justify-center gap-1.5 text-center text-xs text-muted-foreground">
+            {!terminal && !isError && <Loader2 className="size-3 shrink-0 animate-spin text-sky-500" />}
+            <span className={fetchError ? 'text-amber-500' : undefined}>
+              {fetchError ? '获取进度失败，重试中…' : caption}
+            </span>
+          </div>
+        </div>
+      </DialogContent>
+    </Dialog>
+  );
+}

frontend-web/src/open-canvas/components/ai-writing/AIWritingHistoryDropdown.tsx

@@ -1,5 +1,5 @@
 import { useState, useRef, useEffect } from 'react';
-import { History, Trash2, Check, X, RefreshCw } from 'lucide-react';
+import { History, Trash2, Check, X, RefreshCw, Loader2 } from 'lucide-react';
 
 import { Button } from '@/components/ui/button';
 import { cn } from '@/lib/utils';
@@ -7,6 +7,8 @@ import type { AIWritingSessionSummary } from '../../api/ai-writing-sessions';
 
 export const STATUS_LABELS: Record<string, { label: string; color: string }> = {
   in_progress: { label: '进行中', color: 'text-blue-500' },
+  // 后台挂起中：后端正自动驱动到定稿（离页/刷新/切号不打断）。
+  background:   { label: '挂起中', color: 'text-sky-500' },
   draft_ready:  { label: '草稿', color: 'text-amber-500' },
   review_ready: { label: '审核', color: 'text-purple-500' },
   done:         { label: '完成', color: 'text-green-500' },
@@ -29,11 +31,15 @@ export interface SessionItemProps {
   session: AIWritingSessionSummary;
   isSelected: boolean;
   onSelect: () => void;
+  /** 「挂起中」记录点击时改为查看进度（流程图弹窗），不直接打开会话。 */
+  onShowProgress?: () => void;
   onDelete: () => void;
   onRename: (title: string) => void;
 }
 
-export function SessionItem({ session, isSelected, onSelect, onDelete, onRename }: SessionItemProps) {
+export function SessionItem({ session, isSelected, onSelect, onShowProgress, onDelete, onRename }: SessionItemProps) {
+  const isBackground = session.status === 'background';
+  const handleRowClick = isBackground && onShowProgress ? onShowProgress : onSelect;
   const [editing, setEditing] = useState(false);
   const [editValue, setEditValue] = useState(session.title);
   const inputRef = useRef<HTMLInputElement>(null);
@@ -60,7 +66,7 @@ export function SessionItem({ session, isSelected, onSelect, onDelete, onRename
         'group relative flex items-start gap-2 px-3 py-2.5 cursor-pointer transition-colors',
         isSelected ? 'bg-accent' : 'hover:bg-accent/60',
       )}
-      onClick={!editing ? onSelect : undefined}
+      onClick={!editing ? handleRowClick : undefined}
     >
       <div className="flex-1 min-w-0">
         {editing ? (
@@ -89,7 +95,10 @@ export function SessionItem({ session, isSelected, onSelect, onDelete, onRename
           </p>
         )}
         <div className="flex items-center gap-1.5 mt-0.5">
-          <span className={cn('text-[10px] font-medium', color)}>{label}</span>
+          <span className={cn('flex items-center gap-0.5 text-[10px] font-medium', color)}>
+            {session.status === 'background' && <Loader2 className="w-2.5 h-2.5 animate-spin" />}
+            {label}
+          </span>
           <span className="text-[10px] text-muted-foreground">·</span>
           <span className="text-[10px] text-muted-foreground">{formatRelative(session.updated_at)}</span>
         </div>
@@ -114,6 +123,8 @@ interface AIWritingHistoryDropdownProps {
   selectedId: string | null;
   loading: boolean;
   onSelect: (session: AIWritingSessionSummary) => void;
+  /** 点击「挂起中」记录时查看进度（流程图弹窗），不直接打开会话。 */
+  onShowProgress?: (session: AIWritingSessionSummary) => void;
   onDelete: (id: string) => void;
   onRename: (id: string, title: string) => void;
   onRefresh: () => void;
@@ -124,6 +135,7 @@ export function AIWritingHistoryDropdown({
   selectedId,
   loading,
   onSelect,
+  onShowProgress,
   onDelete,
   onRename,
   onRefresh,
@@ -189,6 +201,7 @@ export function AIWritingHistoryDropdown({
                   session={s}
                   isSelected={s.id === selectedId}
                   onSelect={() => { onSelect(s); setOpen(false); }}
+                  onShowProgress={onShowProgress ? () => { onShowProgress(s); setOpen(false); } : undefined}
                   onDelete={() => onDelete(s.id)}
                   onRename={(title) => onRename(s.id, title)}
                 />

frontend-web/src/open-canvas/components/ai-writing/AIWritingHistoryView.tsx

@@ -1,8 +1,34 @@
+import { useMemo } from 'react';
 import { CheckCircle2, ChevronRight, FileText, Search, PenLine, ClipboardEdit, Star } from 'lucide-react';
 
 import type { AIWritingSessionSummary, CompletedInterventionRecord } from '../../api/ai-writing-sessions';
+import {
+  normalizeProgressDict,
+  normalizeMaterial,
+  normalizeOutline,
+  normalizeReviewResult,
+} from '../../hooks/useAIWritingStream';
+import type { CompletedIntervention } from '../../types/ai-writing';
 import { AIWritingTimeline } from './AIWritingTimeline';
 
+/**
+ * 归一化一条 completedIntervention（后台挂起重建的干预记录里素材/大纲/审核数据是
+ * snake_case，前端干预卡期望 camelCase）。对前端实时存的 camelCase 记录幂等。
+ */
+function normalizeCompletedIntervention(rec: Record<string, unknown>): CompletedIntervention {
+  const out: Record<string, unknown> = { ...rec };
+  out.pausePoint = rec.pausePoint ?? rec.pause_point;
+  if (Array.isArray(rec.materials)) {
+    out.materials = (rec.materials as Record<string, unknown>[]).map(normalizeMaterial);
+  }
+  if (rec.outline) out.outline = normalizeOutline(rec.outline);
+  const rr = rec.reviewResult ?? rec.review_result;
+  if (rr) out.reviewResult = normalizeReviewResult(rr);
+  if (out.draftTitle == null && rec.draft_title != null) out.draftTitle = rec.draft_title;
+  if (out.draftWordCount == null && rec.draft_word_count != null) out.draftWordCount = rec.draft_word_count;
+  return out as unknown as CompletedIntervention;
+}
+
 const PAUSE_LABELS: Record<string, string> = {
   material_confirm: '素材确认',
   outline_confirm:  '大纲确认',
@@ -67,6 +93,22 @@ export function AIWritingHistoryView({ session }: AIWritingHistoryViewProps) {
   const transcript = session.transcript;
   // 有完整时间线快照时，复用实时对话的 AIWritingTimeline 渲染，保证回显与实时一致
   const hasTranscript = !!transcript && (transcript.progressEvents?.length ?? 0) > 0;
+  // 归一化 transcript 事件：后台挂起跑出的事件是 raw（snake_case），前端实时存的是
+  // camelCase——统一过一遍 normalizeProgressDict（幂等），两种来源回显都正确一致。
+  const normalizedEvents = useMemo(
+    () => (transcript?.progressEvents ?? []).map(
+      (e) => normalizeProgressDict(e as unknown as Record<string, unknown>, session.id),
+    ),
+    [transcript, session.id],
+  );
+  // 干预记录同样归一化（后台重建的素材/大纲/审核数据为 snake_case；前端实时记录已是
+  // camelCase，归一化幂等），保证素材列表/大纲/编辑审核卡片正确渲染。
+  const normalizedInterventions = useMemo(
+    () => (transcript?.completedInterventions ?? []).map(
+      (rec) => normalizeCompletedIntervention(rec as unknown as Record<string, unknown>),
+    ),
+    [transcript],
+  );
   const createdAt = session.created_at
     ? new Date(session.created_at).toLocaleString('zh-CN', {
         year: 'numeric', month: 'short', day: 'numeric',
@@ -94,8 +136,8 @@ export function AIWritingHistoryView({ session }: AIWritingHistoryViewProps) {
       {hasTranscript ? (
         /* 完整对话时间线回显 */
         <AIWritingTimeline
-          events={transcript!.progressEvents}
-          completedInterventions={transcript!.completedInterventions ?? []}
+          events={normalizedEvents}
+          completedInterventions={normalizedInterventions}
           currentPause={null}
         />
       ) : (

frontend-web/src/open-canvas/components/ai-writing/AIWritingPanel.tsx

@@ -1,6 +1,6 @@
 import { useCallback, useEffect, useRef, useState } from 'react';
 import { useNavigate, useSearchParams } from 'react-router-dom';
-import { ChevronsDown, PanelRightClose, Play, Plus, RotateCcw, Settings2, Square, Trash2 } from 'lucide-react';
+import { ChevronsDown, CloudUpload, PanelRightClose, Play, Plus, RotateCcw, Settings2, Square, Trash2 } from 'lucide-react';
 import { toast } from 'sonner';
 
 import { Button } from '@/components/ui/button';
@@ -17,7 +17,12 @@ import { useAIWriting } from '../../contexts/AIWritingContext';
 import { useAIWritingHistory } from '../../contexts/AIWritingHistoryContext';
 import { useWritingFormOptional } from '../../contexts/WritingFormContext';
 import { useAIWritingSessions } from '../../hooks/useAIWritingSessions';
-import { adminCleanupAIWritingSessions, getAIWritingSession } from '../../api/ai-writing-sessions';
+import {
+  adminCleanupAIWritingSessions,
+  getAIWritingSession,
+  suspendAIWritingToBackground,
+  suspendAIWritingToBackgroundKeepalive,
+} from '../../api/ai-writing-sessions';
 
 /**
  * 暂停 / 继续功能开关（默认 false = 关）。
@@ -51,6 +56,7 @@ import { ReviewStreamingView } from './ReviewStreamingView';
 import { RevisionSummaryCard } from './RevisionSummaryCard';
 import { AIWritingHistoryDropdown } from './AIWritingHistoryDropdown';
 import { AIWritingHistoryView } from './AIWritingHistoryView';
+import { AIWritingFlowDialog } from './AIWritingFlowDialog';
 import type { AIWritingSessionSummary } from '../../api/ai-writing-sessions';
 
 const STATUS_LABEL: Record<string, string> = {
@@ -91,6 +97,8 @@ export function AIWritingPanel({
   useEffect(() => { refreshArticleTypes(); }, [refreshArticleTypes]);
 
   const [reqDialogOpen, setReqDialogOpen] = useState(false);
+  // 「查看进度」流程图弹窗当前展示的会话（点击历史里的「挂起中」记录时打开）。
+  const [progressSession, setProgressSession] = useState<AIWritingSessionSummary | null>(null);
 
   const isIdle = state.status === 'idle';
   const isDone = state.status === 'done';
@@ -188,11 +196,57 @@ export function AIWritingPanel({
     void openHistory(session);
   }, [openHistory]);
 
+  // 点击历史里的「挂起中」记录 → 打开流程图弹窗看实际进度（而非直接打开会话）。
+  const handleShowProgress = useCallback((session: AIWritingSessionSummary) => {
+    setProgressSession(session);
+  }, []);
+
   const handleNewSession = useCallback(() => {
     closeHistory();
     reset();
   }, [closeHistory, reset]);
 
+  // ── 后台挂起：把当前写作转后台，后端自动驱动到定稿（离页/刷新/切号不打断） ──
+  const handleBackgroundSuspend = useCallback(async () => {
+    const sid = state.sessionId;
+    if (!sid) {
+      toast.error('当前没有可挂起的写作会话');
+      return;
+    }
+    try {
+      await suspendAIWritingToBackground(sid);
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : '后台挂起失败');
+      return;
+    }
+    toast.success('已转入后台自动完成，稍后可在「历史记录」查看进度与结果');
+    // reset() 会 stop 客户端 SSE 订阅并回到 idle —— 后端驱动器接管续跑，不冲突。
+    reset();
+    // 刷新历史列表，让「挂起中」徽标立刻出现。
+    refresh();
+  }, [state.sessionId, reset, refresh]);
+
+  // 离页 / 刷新 / 关标签页时，若写作仍在进行中则自动转后台（与圆桌「自动挂起」一致）。
+  // 用 ref 持有最新的「是否在跑 + 会话 id」，让卸载/卸载前回调读到即时值。
+  const suspendRef = useRef<{ running: boolean; sid: string | null }>({ running: false, sid: null });
+  useEffect(() => {
+    suspendRef.current = { running: isRunning, sid: state.sessionId ?? null };
+  }, [isRunning, state.sessionId]);
+
+  useEffect(() => {
+    const onBeforeUnload = () => {
+      const { running, sid } = suspendRef.current;
+      if (running && sid) suspendAIWritingToBackgroundKeepalive(sid);
+    };
+    window.addEventListener('beforeunload', onBeforeUnload);
+    return () => {
+      window.removeEventListener('beforeunload', onBeforeUnload);
+      // 组件卸载（路由离开本页 / 切换工作区标签）：写作未完成则自动转后台。
+      const { running, sid } = suspendRef.current;
+      if (running && sid) suspendAIWritingToBackgroundKeepalive(sid);
+    };
+  }, []);
+
   // ── 侧边栏"最近写作"通信：两种路径 ────────────────────────────────────────
   // 用 ref 包住 handler，保证事件监听器始终能拿到最新版本
   const handleSelectHistoryRef = useRef(handleSelectHistory);
@@ -299,6 +353,19 @@ export function AIWritingPanel({
               新建
             </Button>
           )}
+          {/* 后台挂起：写作进行中（含等待干预）时出现，点击后由后端自动跑完剩余流程 */}
+          {isRunning && !isHistoryMode && state.sessionId && (
+            <Button
+              variant="ghost"
+              size="sm"
+              className="h-7 px-2 text-xs gap-1 text-sky-500 hover:text-sky-600 hover:bg-sky-50 dark:hover:bg-sky-950/30"
+              onClick={handleBackgroundSuspend}
+              title="转入后台：自动确认素材/大纲、写作、编辑审核直至定稿，离开页面也不中断"
+            >
+              <CloudUpload className="size-3" />
+              后台挂起
+            </Button>
+          )}
           {/* ⏸️/▶️ "停止 / 继续" 由 ENABLE_PAUSE_RESUME_UI 控制（默认 false 隐藏）。
               后期把 flag 翻成 true 即可恢复，UI / hook 全套代码都已就位。 */}
           {ENABLE_PAUSE_RESUME_UI && isRunning && !state.isPaused && (
@@ -340,6 +407,7 @@ export function AIWritingPanel({
             selectedId={historySession?.id ?? null}
             loading={sessionsLoading}
             onSelect={handleSelectHistory}
+            onShowProgress={handleShowProgress}
             onDelete={remove}
             onRename={rename}
             onRefresh={refresh}
@@ -533,6 +601,13 @@ export function AIWritingPanel({
         </div>
       )}
 
+      {/* 查看进度流程图弹窗：点击历史里的「挂起中」记录时打开 */}
+      <AIWritingFlowDialog
+        session={progressSession}
+        open={progressSession !== null}
+        onOpenChange={(o) => { if (!o) setProgressSession(null); }}
+      />
+
       {/* 写作参数查看弹窗 */}
       {state.request && (
         <Dialog open={reqDialogOpen} onOpenChange={setReqDialogOpen}>

frontend-web/src/open-canvas/components/ai-writing/ResearchSidebar.tsx

@@ -190,7 +190,7 @@ export function ResearchSidebar({
   };
 
   return (
-    <aside className="flex h-full w-[320px] shrink-0 flex-col overflow-hidden border-r border-slate-100 bg-white text-slate-700 shadow-[1px_0_18px_rgba(15,23,42,0.03)]">
+    <aside className="ai-research-sidebar flex h-full w-[320px] shrink-0 flex-col overflow-hidden border-r border-slate-100 bg-white text-slate-700 shadow-[1px_0_18px_rgba(15,23,42,0.03)]">
       <div className="flex min-h-0 flex-1 flex-col overflow-y-auto overflow-x-hidden px-3 py-4">
         <section className="mb-5">
           <div className="mb-3 flex items-center justify-between gap-3 px-1">

frontend-web/src/open-canvas/contexts/AIWritingContext.tsx

@@ -15,6 +15,11 @@ import {
 import { useStream } from '@langchain/langgraph-sdk/react';
 
 import { getAPIClient } from '@/core/api';
+import {
+  getStreamErrorMessage,
+  isThreadNotAccessibleError,
+  notifyThreadAccessChangedAndReload,
+} from '@/core/threads/thread-access-error';
 
 import { useCanvasGraphContext } from '../contexts/CanvasGraphContext';
 import { saveAIWritingTranscript } from '../api/ai-writing-sessions';
@@ -186,10 +191,18 @@ const AIWritingStreamHost = memo(function AIWritingStreamHost({
     },
     onError(err: unknown) {
       eventBatcherRef.current?.cancel();
-      dispatchRef.current?.({
-        type: 'set_error',
-        message: err instanceof Error ? err.message : String(err),
-      });
+      const message = getStreamErrorMessage(err);
+      // A "thread not accessible/not found" 404 almost always means the writing
+      // thread belongs to a previous login session — the user switched accounts
+      // (or this tab outlived a re-login), so the current account legitimately
+      // can't access the old thread. Instead of dumping the raw HTTP 404 into
+      // the panel, re-frame it around the current identity and reload — same UX
+      // the chat stream gives (see core/threads/hooks.ts).
+      if (isThreadNotAccessibleError(message)) {
+        notifyThreadAccessChangedAndReload();
+        return;
+      }
+      dispatchRef.current?.({ type: 'set_error', message });
     },
     onFinish(finishState) {
       eventBatcherRef.current?.cancel();
@@ -291,7 +304,12 @@ export function AIWritingProvider({ children }: { children: ReactNode }) {
         },
       );
     } catch (err) {
-      dispatch({ type: 'set_error', message: err instanceof Error ? err.message : String(err) });
+      const message = getStreamErrorMessage(err);
+      if (isThreadNotAccessibleError(message)) {
+        notifyThreadAccessChangedAndReload();
+        return;
+      }
+      dispatch({ type: 'set_error', message });
     }
   }, [state.status]);
 
@@ -367,12 +385,24 @@ export function AIWritingProvider({ children }: { children: ReactNode }) {
     dispatch({ type: 'intervention_submitted', record, nextStatus, pendingRevisionContext });
 
     try {
+      // resume 是新 invocation，其 config 默认不带最初的 model_name；而写作/审核节点
+      // 在 resume 后才运行，若首轮 intent 未把模型存进 state（历史会话 / 捕获为空），
+      // 后端就只能回退默认模型。这里把表单选定的模型随每次 resume 一并回传，
+      // 让后端（get_writing_model / resolve_agent_model_name 的 configurable 兜底）
+      // 始终用上用户真正选的模型。
+      const resumeModelName = state.request?.modelName;
       await stream.submit(undefined, {
         command: { resume: resumePayload },
         streamMode: ['values', 'updates', 'custom', 'messages-tuple'],
+        ...(resumeModelName ? { config: { configurable: { model_name: resumeModelName } } } : {}),
       });
     } catch (err) {
-      dispatch({ type: 'set_error', message: err instanceof Error ? err.message : String(err) });
+      const message = getStreamErrorMessage(err);
+      if (isThreadNotAccessibleError(message)) {
+        notifyThreadAccessChangedAndReload();
+        return;
+      }
+      dispatch({ type: 'set_error', message });
     }
   }, [state.sessionId, state.currentPause, state.materials, state.outline,
   state.currentDraftTitle, state.currentDraftMarkdown, state.reviewResult,

frontend-web/src/open-canvas/hooks/useAIWritingStream.ts

@@ -395,7 +395,7 @@ function handleEvent(prev: AIWritingState, event: ProgressEvent): AIWritingState
 
 // ── snake_case ↔ camelCase 归一化（custom 通道事件 + interrupt payload） ──────
 
-function normalizeMaterial(m: Record<string, unknown>): AIMaterial {
+export function normalizeMaterial(m: Record<string, unknown>): AIMaterial {
   const extra = (m.extra_metadata ?? m.extraMetadata) as Record<string, unknown> | undefined;
   return {
     id: String(m.id ?? ''),
@@ -430,7 +430,7 @@ function normalizeOutlineSection(s: Record<string, unknown>) {
   };
 }
 
-function normalizeOutline(o: unknown): AIOutline | null {
+export function normalizeOutline(o: unknown): AIOutline | null {
   if (!o || typeof o !== 'object') return null;
   const obj = o as Record<string, unknown>;
   return {
@@ -449,7 +449,7 @@ function normalizeReviewIssue(i: Record<string, unknown>): ReviewIssue {
   };
 }
 
-function normalizeReviewResult(r: unknown): ReviewResult | null {
+export function normalizeReviewResult(r: unknown): ReviewResult | null {
   if (!r || typeof r !== 'object') return null;
   const o = r as Record<string, unknown>;
   return {
@@ -472,8 +472,12 @@ function normalizeBlockedSection(b: Record<string, unknown>): BlockedSection {
   };
 }
 
-/** 把后端节点 ``progress_events`` 数组里的一条 dict 翻译成前端 ProgressEvent。 */
-function normalizeProgressDict(parsed: Record<string, unknown>, sessionId: string): ProgressEvent {
+/** 把后端节点 ``progress_events`` 数组里的一条 dict 翻译成前端 ProgressEvent。
+ *
+ * 幂等：对已是 camelCase 的前端事件再跑一遍基本不变（snake_case 键不存在即跳过），
+ * 所以历史回显时可无脑对**整条** transcript 跑一遍——既归一后台存的 raw 事件，又
+ * 不破坏前端实时存的事件。 */
+export function normalizeProgressDict(parsed: Record<string, unknown>, sessionId: string): ProgressEvent {
   const out: Record<string, unknown> = { ...parsed, sessionId };
 
   if ('agent_name' in out) out.agentName = out.agent_name;

frontend-web/src/pages/AgentChatPage.tsx

@@ -2,11 +2,13 @@
 
 import { BotIcon, PlusSquare } from "lucide-react";
 import { useParams, useRouter } from "next/navigation";
+import { useLocation } from "react-router-dom";
 import { useRouteBase } from "@/core/route-base";
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 
 import type { PromptInputMessage } from "@/components/ai-elements/prompt-input";
 import { Button } from "@/components/ui/button";
+import { AgentChatSidebar } from "@/components/workspace/agents/agent-chat-sidebar";
 import { AgentDetailPanel } from "@/components/workspace/agents/agent-detail-panel";
 import { AgentQuestionChips } from "@/components/workspace/agents/agent-question-chips";
 import { AgentWelcome } from "@/components/workspace/agent-welcome";
@@ -37,6 +39,9 @@ export default function AgentChatPage({
   embeddedAgentId,
   chatBasePath,
   taskGate,
+  taskBind,
+  autoStartWhenPurposeEmpty,
+  showAgentList,
 }: {
   /** 当作为「通用问答右侧嵌入」渲染时由父组件传入的 agent id（替代路由参数）。
    *  传入即视为嵌入态：路由仍停留在 /chats/new，仅右侧问答区换成该智能体的对话。 */
@@ -49,6 +54,14 @@ export default function AgentChatPage({
   /** rwfx 任务深链闸门：新建对话时顶部展示目的树面板（覆盖确认后才开始问答），
    *  并给新建 thread 打 `metadata.taskId` 标签（任务↔对话 1:N）。见 task-purpose。 */
   taskGate?: boolean;
+  /** 3qfx / xdfx 任务深链：仅做任务↔对话 1:N 绑定（打 `metadata.taskId` 标签 + 切换会话停旧 run），
+   *  不展示目的树闸门；新建对话直接把任务开场信息自动发出。与 `taskGate` 互斥使用。 */
+  taskBind?: boolean;
+  /** rwfx：查询任务目的为空数据时，自动开始第一次问答（跳过手动点「开始问答」）。 */
+  autoStartWhenPurposeEmpty?: boolean;
+  /** 是否在最左侧展示「智能体列表」栏（顶部下拉切换 我的/广场，点击进入该智能体对话）。
+   *  仅独立的智能体问答整页开启；任务工作区 / 模块页 / 嵌入态不传（各有自己的左栏）。 */
+  showAgentList?: boolean;
 } = {}) {
   const routeBase = useRouteBase();
   const { t } = useI18n();
@@ -63,15 +76,28 @@ export default function AgentChatPage({
   // 对话路由前缀：调用方可覆盖（任务深链嵌入态），否则用当前 routeBase 下的独立智能体对话路径。
   const agentChatsBase = chatBasePath ?? `${routeBase}/agents/${agent_id}/chats`;
 
-  // rwfx 任务闸门：读取登录深链/「新建对话」暂存的任务上下文（taskId + 开场信息）。
+  // 任务深链上下文（taskId + 开场信息）：闸门(rwfx)与纯绑定(3qfx/xdfx)都要读取。
+  const taskCtxOn = !!(taskGate || taskBind);
   const taskContext = useMemo(
-    () => (taskGate ? readTaskContext() : null),
-    [taskGate],
+    () => (taskCtxOn ? readTaskContext() : null),
+    [taskCtxOn],
   );
   const taskId =
-    taskGate && taskContext && taskContext.agentId === agent_id
+    taskCtxOn && taskContext && taskContext.agentId === agent_id
       ? taskContext.taskId
       : "";
+  // 纯绑定（taskBind，无闸门，3qfx/xdfx）：新建对话进问答页后，右上角「开始回答」按钮点击时
+  // 发出的任务开场信息。不再自动发（避免新建对话竞态重复发送），改由用户手动点按钮触发。
+  // rwfx 走目的树闸门「开始问答」，不在此列。
+  const taskStartText =
+    taskBind && !taskGate && taskContext && taskContext.agentId === agent_id
+      ? (taskContext.openingText?.trim() ?? "")
+      : "";
+  // 「首次进入且该任务无历史」信号：由 TaskFxIndexResolver 在「无聊天对话 → /new」时注入
+  // （用户主动点「新建对话」不带）。3qfx/xdfx 据此自动发出开场词、跳过「开始回答」按钮；
+  // rwfx 据此决定目的树为空时是否自动开始（仍由 TaskPurposePanel 在有数据时弹覆盖确认）。
+  const location = useLocation();
+  const taskAutoStart = !!(location.state as { taskAutoStart?: boolean } | null)?.taskAutoStart;
 
   // If ChatPage stashed an opening message for this agent, skip the landing
   // screen on first render so the user doesn't see a flash of the welcome UI
@@ -88,7 +114,7 @@ export default function AgentChatPage({
     }
   };
   const [hasStartedConversation, setHasStartedConversation] = useState(
-    hasPendingForThisAgent,
+    () => hasPendingForThisAgent(),
   );
 
   const { agent, isLoading: isAgentLoading } = useAgent(agent_id);
@@ -162,20 +188,20 @@ export default function AgentChatPage({
   );
 
   // 任务流程：切换 / 新建会话时，停掉「上一会话服务端在跑」的 run（老对话要停止）。
-  // 仅 taskGate（rwfx 任务工作区）启用——普通问答页保留后台续跑行为不变。
+  // 任务工作区（rwfx 闸门 + 3qfx/xdfx 纯绑定）启用——普通问答页保留后台续跑行为不变。
   const prevTaskThreadRef = useRef<string | null>(null);
   useEffect(() => {
-    if (!taskGate) return;
+    if (!taskCtxOn) return;
     const prev = prevTaskThreadRef.current;
     if (prev && prev !== threadId) void stopThreadRun(prev);
     prevTaskThreadRef.current = threadId ?? null;
-  }, [taskGate, threadId]);
+  }, [taskCtxOn, threadId]);
   useEffect(() => {
     // 离开任务问答页（卸载）时也停掉当前会话的服务端 run。
     return () => {
-      if (taskGate) void stopThreadRun(prevTaskThreadRef.current);
+      if (taskCtxOn) void stopThreadRun(prevTaskThreadRef.current);
     };
-  }, [taskGate]);
+  }, [taskCtxOn]);
 
   // 任务闸门通过（无目的数据 / 覆盖成功）：发出开场信息开始问答；无开场信息则
   // 仅切到对话态（隐藏面板），让用户手动输入。
@@ -210,6 +236,24 @@ export default function AgentChatPage({
     handleSubmit({ text: pending.text, files: [] });
   }, [agent_id, threadId, isNewThread, handleSubmit]);
 
+  // 纯绑定任务深链（3qfx/xdfx）：用户主动「新建对话」进 landing 后，由 header 右上角「开始回答」
+  // 按钮手动触发发出开场信息（见下方 header）。手动场景不自动发，避免新建对话竞态导致的重复发送。
+  const handleTaskStart = useCallback(() => {
+    if (taskStartText) handleSubmit({ text: taskStartText, files: [] });
+  }, [handleSubmit, taskStartText]);
+
+  // 首次进入且该任务无历史（taskAutoStart）：3qfx/xdfx 直接自动发出开场信息，无需手动点「开始回答」。
+  // autoStartedRef 一次性、不随 threadId 抖动重置，故只发一次（首次进入是干净 mount，无上一会话之忧）。
+  const autoStartedRef = useRef(false);
+  useEffect(() => {
+    if (!taskAutoStart) return;
+    if (!taskStartText) return;
+    if (!isNewThread) return;
+    if (autoStartedRef.current) return;
+    autoStartedRef.current = true;
+    handleSubmit({ text: taskStartText, files: [] });
+  }, [taskAutoStart, taskStartText, isNewThread, handleSubmit]);
+
   const handleClarificationSubmit = useCallback(
     (answer: string) => {
       setHasStartedConversation(true);
@@ -223,8 +267,9 @@ export default function AgentChatPage({
   }, [thread]);
 
   const isLandingState = isNewThread && !hasStartedConversation;
-  // 任务闸门面板：仅在新建对话且尚未开始时，于问答页顶部展示目的树 + 覆盖确认。
-  const showTaskGate = !!taskId && isNewThread && !hasStartedConversation;
+  // 任务闸门面板：仅 rwfx（taskGate）在新建对话且尚未开始时，于问答页顶部展示目的树 + 覆盖确认。
+  // 3qfx/xdfx（taskBind）不展示闸门，新建对话进问答页后由右上角「开始回答」按钮手动发出开场信息。
+  const showTaskGate = !!taskGate && !!taskId && isNewThread && !hasStartedConversation;
   const isDemoMode = env.NEXT_PUBLIC_STATIC_WEBSITE_ONLY === "true";
 
   const status = thread.error
@@ -241,6 +286,8 @@ export default function AgentChatPage({
           always opens between the chat and the detail panel — the detail
           panel stays rightmost. */}
       <div className="flex size-full min-h-0 overflow-hidden workspace-chat-bg">
+        {/* 最左：智能体列表栏（仅独立整页问答开启）。顶部下拉切换 我的/广场。 */}
+        {showAgentList && <AgentChatSidebar activeAgentId={agent_id} />}
         <div className="min-h-0 min-w-0 flex-1">
           <ChatBox threadId={threadId}>
             {/* Main conversation column. `relative` hosts the floating
@@ -263,6 +310,18 @@ export default function AgentChatPage({
                 </div>
 
                 <div className="flex items-center">
+                  {/* 3qfx/xdfx 任务深链：用户主动「新建对话」进问答页后，点此发出任务开场信息开始问答。
+                      首次进入且无历史（taskAutoStart）会自动发，不显示此按钮。 */}
+                  {taskStartText && isLandingState && !taskAutoStart && (
+                    <Button
+                      size="sm"
+                      className="mr-1 bg-[var(--color-main)] text-white shadow-sm hover:bg-[var(--brand-950)]"
+                      onClick={handleTaskStart}
+                      disabled={isDemoMode}
+                    >
+                      开始回答
+                    </Button>
+                  )}
                   <Tooltip content={t.agents.newChat}>
                     <Button
                       size="sm"
@@ -290,7 +349,13 @@ export default function AgentChatPage({
               </header>
 
               {showTaskGate && (
-                <TaskPurposePanel taskId={taskId} onStart={handleGateStart} />
+                <TaskPurposePanel
+                  taskId={taskId}
+                  onStart={handleGateStart}
+                  // rwfx：仅「首次进入且无聊天对话历史」(taskAutoStart) 时，目的树为空才自动开始；
+                  // 用户主动新建对话则需手动点「开始问答」。目的树有数据始终弹「覆盖并开始问答」确认。
+                  autoStartWhenEmpty={!!autoStartWhenPurposeEmpty && taskAutoStart}
+                />
               )}
 
               {isLandingState ? (
@@ -403,6 +468,7 @@ export default function AgentChatPage({
           agentName={agentDisplayName}
           disabled={thread.isLoading || isDemoMode}
           onAskQuestion={(text) => handleSubmit({ text, files: [] })}
+          defaultCollapsed={taskCtxOn}
         />
       </div>
     </ThreadContext.Provider>

frontend-web/src/pages/AgentModulePage.tsx

@@ -75,7 +75,9 @@ function ModuleChatShell({ module }: { module: AgentModuleConfig }) {
   const [settingsOpen, setSettingsOpen] = useState(false);
 
   return (
-    <div className="flex size-full min-h-0 overflow-hidden">
+    // 外壳挂 workspace-chat-bg：深色下整片用同一张深蓝主题底图（fixed），作为左栏半透明
+    // 玻璃面板透出的「底色」；浅色透明无影响。右侧对话区自带同款底图，左右底色一致。
+    <div className="workspace-chat-bg flex size-full min-h-0 overflow-hidden">
       <AgentModuleSidebar
         moduleKey={module.key}
         activeAgentId={agent_id}

frontend-web/src/pages/BusinessChainMappingPage.tsx

@@ -145,8 +145,8 @@ export default function BusinessChainMappingPage() {
 
   /* ── 样式 ── */
   const shellClass = isDark
-    ? "h-full overflow-y-auto text-slate-100 workspace-chat-bg"
-    : "h-full overflow-y-auto bg-white text-[#222]";
+    ? "size-full min-h-0 overflow-y-auto text-slate-100 workspace-chat-bg"
+    : "size-full min-h-0 overflow-y-auto bg-white text-[#222]";
 
   // 卡片：无边框，纯阴影
   const cardClass = isDark

frontend-web/src/pages/LlmMetricsPage.tsx

@@ -14,6 +14,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from "@/components/ui/select";
+import { ScrollArea } from "@/components/ui/scroll-area";
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { ToolMetricsPanel } from "@/components/workspace/admin/tool-metrics-panel";
 import {
@@ -494,14 +495,18 @@ function Td({
 export default function LlmMetricsPage() {
   const [tab, setTab] = useState<"llm" | "tool">("llm");
   return (
-    <div className="mx-auto flex w-full max-w-6xl flex-col gap-4 px-6 py-8">
-      <Tabs value={tab} onValueChange={(v) => setTab(v as "llm" | "tool")}>
-        <TabsList>
-          <TabsTrigger value="llm">大模型调用</TabsTrigger>
-          <TabsTrigger value="tool">工具调用</TabsTrigger>
-        </TabsList>
-      </Tabs>
-      {tab === "llm" ? <LlmMetricsPanel /> : <ToolMetricsPanel />}
+    <div className="flex size-full min-h-0 w-full">
+      <ScrollArea className="min-h-0 flex-1">
+        <div className="mx-auto flex w-full max-w-6xl flex-col gap-4 px-6 py-8">
+          <Tabs value={tab} onValueChange={(v) => setTab(v as "llm" | "tool")}>
+            <TabsList>
+              <TabsTrigger value="llm">大模型调用</TabsTrigger>
+              <TabsTrigger value="tool">工具调用</TabsTrigger>
+            </TabsList>
+          </Tabs>
+          {tab === "llm" ? <LlmMetricsPanel /> : <ToolMetricsPanel />}
+        </div>
+      </ScrollArea>
     </div>
   );
 }

frontend-web/src/pages/LoginPage.tsx

@@ -15,10 +15,12 @@ import {
 import {
   fetchCopTaskDetail,
   persistCopTaskDetail,
+  resolveDeeplinkTaskId,
   resolveTaskDeeplinkTarget,
 } from '@/core/auth/task-deeplink';
 import { resolveUsernameByOnlineTicket } from '@/core/auth/wujie-ticket-login';
 import { isWujieEnv, useWujieProps } from '@/core/embed/wujie';
+import { readEmbedParam } from '@/core/embed/embed-session';
 import {
   GENERAL_QA_ROUTE,
   loginByYUserId,
@@ -47,6 +49,13 @@ export default function LoginPage() {
     () => isSidebarEnabledFromSearch(searchParams.toString()),
     [searchParams],
   );
+  // iframe 嵌入模式（外部系统 `&embed=1`）：去 chrome + 按标签页强制主题。嵌入侧**不**走
+  // setTheme / persistSidebarEnabled（那俩落 localStorage、会跨标签污染正常系统页），改用
+  // sessionStorage 嵌入会话（见 embed-session.ts）。`embed=0` 显式关闭。
+  const isEmbed = useMemo(
+    () => readEmbedParam(searchParams.toString()) === 'on',
+    [searchParams],
+  );
   const redirectPath = useMemo(
     () =>
       searchParams.get('from') === IFRAME_LOGIN_SOURCE
@@ -104,11 +113,14 @@ export default function LoginPage() {
 
   // 主题切换:无界 props.theme 优先,其次 URL query theme。两者取值约定一致
   // (dark-blue → 深色;red → 浅色;blue 暂无该主题,先用浅色代替),统一走 resolveThemeFromQuery。
+  // **嵌入模式跳过**:setTheme 会写 localStorage `strategy-theme`，跨标签污染正常系统页；
+  // 嵌入主题改由 forcedTheme（按标签页、不持久化）接管。
   useEffect(() => {
+    if (isEmbed) return;
     const themeValue = wujieProps.theme || externalParams.theme;
     if (!themeValue) return;
     setTheme(resolveThemeFromQuery(themeValue));
-  }, [wujieProps.theme, externalParams.theme, setTheme]);
+  }, [isEmbed, wujieProps.theme, externalParams.theme, setTheme]);
 
   // ticket / userId / env 持久化（与 login 请求并行做，互不阻塞）
   useEffect(() => {
@@ -153,18 +165,23 @@ export default function LoginPage() {
         // 内网透传的 access_token 合并进 userInfo（在 loginByYUserId 覆盖之后），
         // XK/PG 中任务 iframe 据此取 accessToken
         persistAccessToken(accessToken);
-        persistSidebarEnabled(sidebarEnabled);
+        // 嵌入模式不写 sidebarEnabled（localStorage 的「简洁/全量」偏好会跨标签污染正常页）；
+        // 去 chrome 由按标签页的嵌入会话（isEmbedActive）驱动，见 PageLayout。
+        if (!isEmbed) persistSidebarEnabled(sidebarEnabled);
         setStatus('success');
 
         // 任务深链：带 taskId + goPath 时拉任务详情并直送对应问答/会商页；
         // 任一环节失败（无地址/拉取失败/未配置智能体/goPath 无法识别）都回退默认首页。
         if (taskId && goPath) {
           try {
-            const detail = await fetchCopTaskDetail(taskId);
+            // xdfx 深链 ?taskId= 传入的是「行动id」，先换成真正的「任务id」；其它业务原样。
+            const realTaskId = await resolveDeeplinkTaskId(goPath, taskId);
+            if (cancelled) return;
+            const detail = await fetchCopTaskDetail(realTaskId);
             if (cancelled) return;
             if (detail) {
               persistCopTaskDetail(detail);
-              const target = await resolveTaskDeeplinkTarget(goPath, detail, taskId);
+              const target = await resolveTaskDeeplinkTarget(goPath, detail, realTaskId, taskId);
               if (cancelled) return;
               if (target) {
                 navigate(target.path, { replace: true, state: target.state });
@@ -205,6 +222,7 @@ export default function LoginPage() {
     gatePassword,
     taskId,
     goPath,
+    isEmbed,
   ]);
 
   return (

frontend-web/src/pages/MemoryPage.tsx

@@ -2,7 +2,7 @@ import { MemorySettingsPage } from "@/components/workspace/settings/memory-setti
 
 export default function MemoryPage() {
   return (
-    <div className="flex flex-col h-full overflow-auto p-6">
+    <div className="flex size-full min-h-0 flex-col overflow-auto p-6">
       <MemorySettingsPage />
     </div>
   );

frontend-web/src/pages/NewAgentPage.tsx

@@ -83,6 +83,8 @@ export default function NewAgentPage() {
   const [modelInput, setModelInput] = useState<string>("");
   const [chatModelInput, setChatModelInput] = useState<string>("");
   const [templateNameInput, setTemplateNameInput] = useState("");
+  // 会商席位「技能识别强化」开关（弱模型补偿）。默认关。
+  const [seatSkillDirectiveInput, setSeatSkillDirectiveInput] = useState(false);
   const [formError, setFormError] = useState("");
   const [agentId, setAgentId] = useState("");
   const [agent, setAgent] = useState<Agent | null>(null);
@@ -230,6 +232,7 @@ export default function NewAgentPage() {
           skills: selectedSkills,
           model: modelOverride,
           template_name: templateNameInput.trim(),
+          seat_skill_directive: seatSkillDirectiveInput,
         });
         setAgent(updated);
         return updated;
@@ -251,6 +254,7 @@ export default function NewAgentPage() {
         skills: selectedSkills,
         model: modelOverride,
         template_name: templateNameInput.trim(),
+        seat_skill_directive: seatSkillDirectiveInput,
       });
       setAgentId(created.id);
       setAgent(created);
@@ -281,6 +285,7 @@ export default function NewAgentPage() {
     selectedSkills,
     soulInput,
     templateNameInput,
+    seatSkillDirectiveInput,
     t.agents.nameStepCheckError,
     t.agents.nameStepNetworkError,
     validateForm,

frontend-web/src/pages/PageRoutes.tsx

@@ -6,6 +6,7 @@ import { PageSidebarDark } from "@/components/page-sidebar-dark";
 import { isChatsIframeWorkspacePath } from "@/core/page-layout/chats-iframe-route";
 import { readSidebarEnabled } from "@/core/page-layout/sidebar-enabled";
 import { isWujieEnv } from "@/core/embed/wujie";
+import { isEmbedActive, readEmbedParam } from "@/core/embed/embed-session";
 import { useTheme } from "@/contexts/ThemeContext";
 import { useLocation } from "react-router-dom";
 import { useActiveThirdLevel } from "@/core/page-layout/use-sidebar-menu";
@@ -37,8 +38,14 @@ function PageLayout() {
   const [layoutMode] = useLayoutMode();
   const chromeByPreference =
     layoutMode === "full" ? true : layoutMode === "compact" ? false : sidebarEnabled;
+  // iframe 嵌入模式（外部系统 `&embed=1`，按标签页 sessionStorage）：去掉全局导航栏 + 侧边栏，
+  // 只留问答/会商工作区本体。按 location 重算以跟随页内导航；非嵌入标签页恒为 false，不受影响。
+  const embedActive = useMemo(
+    () => isEmbedActive() || readEmbedParam(location.search) === "on",
+    [location.pathname, location.search],
+  );
   const pageSidebarAllowed =
-    chromeByPreference && !isChatsIframeWorkspacePath(location.pathname);
+    chromeByPreference && !isChatsIframeWorkspacePath(location.pathname) && !embedActive;
 
   // h-full(100%)而非 h-screen(100vh):配合 globals.css 的 html/body/#root height:100%
   // 高度链,根布局跟随容器高度。全屏下 100% 解析到视口,与 h-screen 等价;无界等嵌套

frontend-web/src/pages/PublicLeaderboardPage.tsx

@@ -34,6 +34,7 @@ import {
 } from "@/components/ui/dialog";
 import { Input } from "@/components/ui/input";
 import { Pagination } from "@/components/ui/pagination";
+import { ScrollArea } from "@/components/ui/scroll-area";
 import { Tabs, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import type {
   AdminLeaderboardDimension,
@@ -225,7 +226,11 @@ export default function PublicLeaderboardPage() {
   }, [userPageCount]);
 
   return (
-    <div className="min-h-screen w-full bg-[#FFF7F7] text-[#231815] dark:bg-[#011226] dark:text-white" style={pageBg}>
+    <div
+      className="flex size-full min-h-0 w-full bg-[#FFF7F7] text-[#231815] dark:bg-[#011226] dark:text-white"
+      style={pageBg}
+    >
+      <ScrollArea className="min-h-0 flex-1">
       <div className="mx-auto w-full max-w-6xl px-4 py-8 sm:px-6 sm:py-10">
         {/* 标题区：仅展示，不含任何操作按钮 */}
         <header className="mb-6">
@@ -372,6 +377,7 @@ export default function PublicLeaderboardPage() {
           {data?.generated_at ? `数据生成于 ${fmtDate(data.generated_at)}` : "仅供查看"}
         </footer>
       </div>
+      </ScrollArea>
     </div>
   );
 }

frontend-web/src/pages/RoundtableDiagnosticsPage.tsx

@@ -0,0 +1,333 @@
+"use client";
+
+/**
+ * 会商诊断日志（仅 admin）：展示多智能体会商全流程（第一步意图 / 第二步研讨 /
+ * 第三步报告 + 后台挂起执行器 / 进程内网关）各处的报错与关键事件，支持按
+ * scope（前台/后台）、阶段、级别、事件码、作业/任务/草稿 id、关键词筛选 + 分页。
+ *
+ * 数据源：`GET /api/roundtable-diagnostics`（admin-gated）。入口：多智能体会商页右上角
+ * 设置按钮（admin）。见 [[roundtable-diagnostics]]。
+ */
+
+import { useMemo, useState } from "react";
+import { Navigate, useNavigate } from "react-router-dom";
+import { ArrowLeft, RefreshCw, Search } from "lucide-react";
+
+import { Badge } from "@/components/ui/badge";
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import { Pagination } from "@/components/ui/pagination";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { cn } from "@/lib/utils";
+import { getStoredAuth } from "@/core/auth";
+import {
+  type DiagnosticFilters,
+  type DiagnosticItem,
+  useRoundtableDiagnosticFacets,
+  useRoundtableDiagnostics,
+} from "@/strategy-components/api/roundtable-diagnostics";
+
+const PAGE_SIZE = 50;
+
+const ALL = "__all__";
+
+// 阶段中文名（已知集合；未知阶段原样显示）。
+const STAGE_LABELS: Record<string, string> = {
+  step1_intent: "第一步 · 意图",
+  step2_init: "第二步 · 初始化",
+  step2_leader: "第二步 · 总控",
+  step2_seat: "第二步 · 席位",
+  step2_recommend: "第二步 · 推荐",
+  step2_orchestration: "第二步 · 编排",
+  step3_summary: "第三步 · 总结报告",
+  step3_report: "第三步 · 结果绘制",
+  step3_dashboard: "第三步 · 大屏数据",
+  step3_structure: "第三步 · 数据入库",
+  upstream: "回环代理",
+  job: "后台作业",
+};
+
+const SCOPE_LABELS: Record<string, string> = {
+  background: "后台挂起",
+  foreground: "前台实时(服务端)",
+  client: "前端上报",
+};
+
+// 范围切换：后台挂起(background) / 前台调用(foreground 服务端观测 + client 前端上报)。
+type ScopeCategory = "background" | "frontend";
+
+// 每个范围下可选的阶段（按用户要求：后台挂起只到第二/三步；前台调用含第一步）。
+const STAGE_OPTIONS: Record<ScopeCategory, string[]> = {
+  background: [
+    "step2_init",
+    "step2_leader",
+    "step2_seat",
+    "step2_orchestration",
+    "step3_summary",
+    "step3_report",
+    "step3_dashboard",
+    "step3_structure",
+    "job",
+  ],
+  frontend: [
+    "step1_intent",
+    "step2_init",
+    "step2_leader",
+    "step2_seat",
+    "step2_recommend",
+    "step3_summary",
+    "step3_report",
+    "step3_dashboard",
+    "step3_structure",
+  ],
+};
+
+const LEVEL_STYLES: Record<string, string> = {
+  error: "bg-red-100 text-red-700 dark:bg-red-950 dark:text-red-300",
+  warning: "bg-amber-100 text-amber-700 dark:bg-amber-950 dark:text-amber-300",
+  info: "bg-slate-100 text-slate-600 dark:bg-slate-800 dark:text-slate-300",
+};
+
+function stageLabel(stage: string): string {
+  return STAGE_LABELS[stage] ?? stage;
+}
+
+function fmtTime(iso: string | null): string {
+  if (!iso) return "";
+  try {
+    const d = new Date(iso);
+    return d.toLocaleString("zh-CN", { hour12: false });
+  } catch {
+    return iso;
+  }
+}
+
+function DiagnosticRow({ item }: { item: DiagnosticItem }) {
+  const [open, setOpen] = useState(false);
+  const hasDetail = item.detail != null && Object.keys(item.detail as object).length > 0;
+  return (
+    <div className="rounded-lg border border-slate-200 dark:border-border bg-white dark:bg-card px-3 py-2 text-sm">
+      <div className="flex items-start gap-2">
+        <span
+          className={cn(
+            "shrink-0 rounded px-1.5 py-0.5 text-xs font-medium uppercase",
+            LEVEL_STYLES[item.level] ?? LEVEL_STYLES.info,
+          )}
+        >
+          {item.level}
+        </span>
+        <div className="min-w-0 flex-1">
+          <div className="flex flex-wrap items-center gap-x-2 gap-y-1">
+            <Badge variant="secondary" className="text-xs">
+              {stageLabel(item.stage)}
+            </Badge>
+            <code className="text-xs text-slate-500 dark:text-muted-foreground">{item.event}</code>
+            {item.agentName ? (
+              <span className="text-xs text-slate-500 dark:text-muted-foreground">· {item.agentName}</span>
+            ) : null}
+            {item.userName ? (
+              <span className="rounded bg-slate-100 px-1.5 py-0.5 text-xs text-slate-600 dark:bg-slate-800 dark:text-slate-300">
+                👤 {item.userName}
+              </span>
+            ) : null}
+            <span className="ml-auto text-xs text-slate-400 dark:text-muted-foreground">{fmtTime(item.createdAt)}</span>
+          </div>
+          <p className="mt-1 whitespace-pre-wrap break-words text-slate-700 dark:text-foreground">
+            {item.message || <span className="text-slate-400">（无说明）</span>}
+          </p>
+          <div className="mt-1 flex flex-wrap gap-x-3 gap-y-0.5 text-xs text-slate-400 dark:text-muted-foreground">
+            <span>{SCOPE_LABELS[item.scope] ?? item.scope}</span>
+            {item.jobId ? <span>job: {item.jobId.slice(0, 8)}</span> : null}
+            {item.taskId ? <span>task: {item.taskId}</span> : null}
+            {item.draftId ? <span>draft: {item.draftId.slice(0, 8)}</span> : null}
+            {item.cycle != null ? <span>cycle: {item.cycle}</span> : null}
+            {hasDetail ? (
+              <button type="button" className="text-blue-500 hover:underline" onClick={() => setOpen((v) => !v)}>
+                {open ? "收起详情" : "展开详情"}
+              </button>
+            ) : null}
+          </div>
+          {open && hasDetail ? (
+            <pre className="mt-2 max-h-64 overflow-auto rounded bg-slate-50 dark:bg-muted p-2 text-xs text-slate-600 dark:text-muted-foreground">
+              {JSON.stringify(item.detail, null, 2)}
+            </pre>
+          ) : null}
+        </div>
+      </div>
+    </div>
+  );
+}
+
+export default function RoundtableDiagnosticsPage() {
+  const isAdmin = getStoredAuth()?.system_role === "admin";
+  const navigate = useNavigate();
+
+  const [scopeCategory, setScopeCategory] = useState<ScopeCategory>("background");
+  const [stage, setStage] = useState<string>(ALL);
+  const [level, setLevel] = useState<string>(ALL);
+  const [event, setEvent] = useState<string>(ALL);
+  const [qInput, setQInput] = useState("");
+  const [q, setQ] = useState("");
+  const [page, setPage] = useState(1);
+
+  // 「前台调用」= 服务端观测(foreground) + 前端上报(client) 两种 scope 合并查（后端按逗号分隔多值）。
+  const scopeParam = scopeCategory === "background" ? "background" : "foreground,client";
+
+  const filters: DiagnosticFilters = useMemo(
+    () => ({
+      scope: scopeParam,
+      stage: stage === ALL ? undefined : stage,
+      level: level === ALL ? undefined : level,
+      event: event === ALL ? undefined : event,
+      q: q || undefined,
+      limit: PAGE_SIZE,
+      offset: (page - 1) * PAGE_SIZE,
+    }),
+    [scopeParam, stage, level, event, q, page],
+  );
+
+  const { data, isLoading, isFetching, refetch } = useRoundtableDiagnostics(filters, isAdmin);
+  const { data: facets } = useRoundtableDiagnosticFacets(isAdmin);
+
+  if (!isAdmin) {
+    return <Navigate to="/page/workspace/chats/new" replace />;
+  }
+
+  const items = data?.items ?? [];
+  const total = data?.total ?? 0;
+
+  const resetPageAnd = (fn: () => void) => {
+    fn();
+    setPage(1);
+  };
+
+  // 切换范围时清空阶段筛选（两种范围的阶段选项不同）+ 回到第一页。
+  const switchScope = (next: ScopeCategory) => {
+    setScopeCategory(next);
+    setStage(ALL);
+    setPage(1);
+  };
+
+  const applySearch = () => resetPageAnd(() => setQ(qInput.trim()));
+
+  return (
+    <div className="flex h-full flex-col bg-slate-50 dark:bg-background">
+      {/* Header */}
+      <header className="flex items-center gap-3 border-b border-slate-200 dark:border-border bg-white dark:bg-card px-4 py-3">
+        <Button variant="ghost" size="sm" onClick={() => navigate(-1)} className="gap-1">
+          <ArrowLeft className="h-4 w-4" />
+          返回
+        </Button>
+        <div>
+          <h1 className="text-base font-semibold text-slate-800 dark:text-foreground">会商诊断日志</h1>
+          <p className="text-xs text-slate-400 dark:text-muted-foreground">
+            多智能体会商全流程报错与关键事件（含后台挂起卡死、超时、产物缺失等）
+          </p>
+        </div>
+        <Button
+          variant="outline"
+          size="sm"
+          onClick={() => refetch()}
+          className="ml-auto gap-1"
+          disabled={isFetching}
+        >
+          <RefreshCw className={cn("h-4 w-4", isFetching && "animate-spin")} />
+          刷新
+        </Button>
+      </header>
+
+      {/* Filters */}
+      <div className="flex flex-wrap items-center gap-2 border-b border-slate-200 dark:border-border bg-white dark:bg-card px-4 py-2">
+        {/* 范围切换：后台挂起 / 前台调用 */}
+        <div className="inline-flex rounded-lg border border-slate-200 dark:border-border p-0.5">
+          {(["background", "frontend"] as ScopeCategory[]).map((c) => (
+            <button
+              key={c}
+              type="button"
+              onClick={() => switchScope(c)}
+              className={cn(
+                "rounded-md px-3 py-1 text-xs font-medium transition-colors",
+                scopeCategory === c
+                  ? "bg-slate-800 text-white dark:bg-primary dark:text-primary-foreground"
+                  : "text-slate-500 hover:text-slate-700 dark:text-muted-foreground dark:hover:text-foreground",
+              )}
+            >
+              {c === "background" ? "后台挂起" : "前台调用"}
+            </button>
+          ))}
+        </div>
+        <FilterSelect label="阶段" value={stage} onChange={(v) => resetPageAnd(() => setStage(v))}
+          options={STAGE_OPTIONS[scopeCategory]} labels={STAGE_LABELS} />
+        <FilterSelect label="级别" value={level} onChange={(v) => resetPageAnd(() => setLevel(v))}
+          options={facets?.level ?? []} />
+        <FilterSelect label="事件" value={event} onChange={(v) => resetPageAnd(() => setEvent(v))}
+          options={facets?.event ?? []} />
+        <div className="flex items-center gap-1">
+          <Input
+            value={qInput}
+            onChange={(e) => setQInput(e.target.value)}
+            onKeyDown={(e) => e.key === "Enter" && applySearch()}
+            placeholder="搜索报错说明…"
+            className="h-8 w-48"
+          />
+          <Button variant="secondary" size="sm" onClick={applySearch} className="gap-1">
+            <Search className="h-4 w-4" />
+          </Button>
+        </div>
+        <span className="ml-auto text-xs text-slate-400 dark:text-muted-foreground">共 {total} 条</span>
+      </div>
+
+      {/* List */}
+      <div className="flex-1 overflow-auto px-4 py-3">
+        {isLoading ? (
+          <p className="py-10 text-center text-sm text-slate-400">加载中…</p>
+        ) : items.length === 0 ? (
+          <p className="py-10 text-center text-sm text-slate-400">暂无诊断记录</p>
+        ) : (
+          <div className="flex flex-col gap-2">
+            {items.map((it) => (
+              <DiagnosticRow key={it.id} item={it} />
+            ))}
+            <Pagination page={page} pageSize={PAGE_SIZE} total={total} onPageChange={setPage} className="pt-2" />
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function FilterSelect({
+  label,
+  value,
+  onChange,
+  options,
+  labels,
+}: {
+  label: string;
+  value: string;
+  onChange: (v: string) => void;
+  options: string[];
+  labels?: Record<string, string>;
+}) {
+  return (
+    <Select value={value} onValueChange={onChange}>
+      <SelectTrigger className="h-8 w-auto min-w-[120px] text-xs">
+        <SelectValue placeholder={label} />
+      </SelectTrigger>
+      <SelectContent>
+        <SelectItem value={ALL}>{label}：全部</SelectItem>
+        {options.map((o) => (
+          <SelectItem key={o} value={o}>
+            {labels?.[o] ?? o}
+          </SelectItem>
+        ))}
+      </SelectContent>
+    </Select>
+  );
+}

frontend-web/src/pages/SkillEvolutionPage.tsx

@@ -2,7 +2,7 @@ import { SkillEvolutionPanel } from "@/components/workspace/skills/skill-evoluti
 
 export default function SkillEvolutionPage() {
   return (
-    <div className="flex h-full flex-col overflow-auto p-6">
+    <div className="flex size-full min-h-0 flex-col overflow-auto p-6">
       <SkillEvolutionPanel />
     </div>
   );

frontend-web/src/pages/SkillsPage.tsx

@@ -2,7 +2,7 @@ import { SkillSettingsPage } from "@/components/workspace/settings/skill-setting
 
 export default function SkillsPage() {
   return (
-    <div className="flex flex-col h-full overflow-auto p-6">
+    <div className="flex size-full min-h-0 flex-col overflow-auto p-6">
       <SkillSettingsPage />
     </div>
   );

frontend-web/src/pages/StrategyRoutes.tsx

@@ -1,4 +1,4 @@
-import { Navigate, Route, Routes, useParams } from "react-router-dom";
+import { Navigate, Route, Routes } from "react-router-dom";
 import { Toaster } from "sonner";
 
 import { SidebarProvider } from "@/components/ui/sidebar";
@@ -12,6 +12,7 @@ import TaskTyFrom from "@/strategy-components/components/task-components/TaskTyF
 import TaskXkFrom from "@/strategy-components/components/task-components/TaskXkFrom";
 import TaskAnalyzes from "@/strategy-components/components/task-components/TaskAnalyzes";
 import {
+  TaskBindChat,
   TaskFxChat,
   TaskFxIndexResolver,
   TaskFxWorkspace,
@@ -20,6 +21,7 @@ import { ActionAnalyzes } from "@/strategy-components/components/task-components
 import KnowledgeBaseResourceManagement from "@/strategy-components/components/resource-management/KnowledgeBaseResourceManagement";
 import NetworkActorResourceManagement from "@/strategy-components/components/resource-management/NetworkActorResourceManagement";
 import RoundtablePlanningPage from "@/roundtable-planning/pages/RoundtablePlanningPage";
+import DashboardAgentPage from "@/roundtable-planning/pages/DashboardAgentPage";
 import BusinessChainListPage from "@/roundtable-planning/pages/BusinessChainListPage";
 import BusinessChainEditorPage from "@/roundtable-planning/pages/BusinessChainEditorPage";
 import "@/roundtable-planning/styles/roundtable-planning.css";
@@ -38,6 +40,8 @@ import LightAppListPage from "./LightAppListPage";
 import LightAppManagementPage from "./LightAppManagementPage";
 import MenuManagementPage from "./MenuManagementPage";
 import SensitiveWordsPage from "./SensitiveWordsPage";
+import TaskButtonsPage from "./TaskButtonsPage";
+import RoundtableDiagnosticsPage from "./RoundtableDiagnosticsPage";
 import LightAppNewNotePage from "./LightAppNewNotePage";
 import LightAppNoteListPage from "./LightAppNoteListPage";
 import LightAppNoteQAPage from "./LightAppNoteQAPage";
@@ -58,20 +62,6 @@ import AdminScheduledTasksPage from "./AdminScheduledTasksPage";
 import AdminUserActivityPage from "./AdminUserActivityPage";
 import { ChatRuntime } from "./WorkspaceRoutes";
 
-/**
- * 任务深链：把智能体问答嵌进「任务管理」布局。读路由参数 agent_id，给 AgentChatPage
- * 传入以 taskBase 为前缀的对话路由（开新会话 / URL 改写都停留在任务管理上下文，
- * 侧边栏保持对应业务高亮）。
- */
-function TaskEmbeddedAgentChat({ taskBase }: { taskBase: string }) {
-  const { agent_id } = useParams<{ agent_id: string }>();
-  return (
-    <ChatRuntime>
-      <AgentChatPage chatBasePath={`${taskBase}/agent/${agent_id}/chats`} />
-    </ChatRuntime>
-  );
-}
-
 export default function StrategyRoutes() {
   return (
     <RouteBaseProvider value="/page/strategy">
@@ -99,6 +89,16 @@ export default function StrategyRoutes() {
               }
             />
 
+            {/* 大屏绘制智能体独立页面（按 taskId 存取；ChatRuntime 提供 ArtifactsProvider 给沙箱预览） */}
+            <Route
+              path="dashboard-agent"
+              element={
+                <ChatRuntime>
+                  <DashboardAgentPage />
+                </ChatRuntime>
+              }
+            />
+
             {/* 需求 0616 #3/#4：zzJC / zzXD 「按类型聚合」模块页（重做，独立路由）。 */}
             <Route path="qa/zzjc/*" element={<AgentModuleRoutes module={AGENT_MODULES.zzjc} />} />
             <Route path="qa/zzxd/*" element={<AgentModuleRoutes module={AGENT_MODULES.zzxd} />} />
@@ -144,12 +144,26 @@ export default function StrategyRoutes() {
                   </ChatRuntime>
                 }
               />
+              {/* 三情分析：任务工作区（左对话列表 1:N，无目的树闸门；新建对话直接带开场信息）。 */}
               <Route
-                path="plan-task-sentiment/agent/:agent_id/chats/:thread_id"
+                path="plan-task-sentiment/agent/:agent_id/chats"
                 element={
-                  <TaskEmbeddedAgentChat taskBase="/page/strategy/task-management/plan-task-sentiment" />
+                  <TaskFxWorkspace taskBase="/page/strategy/task-management/plan-task-sentiment" business="3qfx" lite />
                 }
-              />
+              >
+                <Route
+                  index
+                  element={
+                    <TaskFxIndexResolver taskBase="/page/strategy/task-management/plan-task-sentiment" />
+                  }
+                />
+                <Route
+                  path=":thread_id"
+                  element={
+                    <TaskBindChat taskBase="/page/strategy/task-management/plan-task-sentiment" />
+                  }
+                />
+              </Route>
               <Route
                 path="plan-task/plan-task-fx"
                 element={
@@ -173,7 +187,7 @@ export default function StrategyRoutes() {
               <Route
                 path="plan-task/plan-task-fx/agent/:agent_id/chats"
                 element={
-                  <TaskFxWorkspace taskBase="/page/strategy/task-management/plan-task/plan-task-fx" />
+                  <TaskFxWorkspace taskBase="/page/strategy/task-management/plan-task/plan-task-fx" business="rwfx" />
                 }
               >
                 <Route
@@ -185,7 +199,10 @@ export default function StrategyRoutes() {
                 <Route
                   path=":thread_id"
                   element={
-                    <TaskFxChat taskBase="/page/strategy/task-management/plan-task/plan-task-fx" />
+                    <TaskFxChat
+                      taskBase="/page/strategy/task-management/plan-task/plan-task-fx"
+                      autoStartWhenPurposeEmpty
+                    />
                   }
                 />
               </Route>
@@ -208,12 +225,28 @@ export default function StrategyRoutes() {
                   </ChatRuntime>
                 }
               />
+              {/* 行动分析：任务工作区（左对话列表 1:N 精简版 + 左上行动详情卡片；直接问答，
+                  右上角「开始回答」按钮手动发出开场信息，不走目的树闸门/覆盖确认）。
+                  注意：xdfx 深链传入的是「行动id」，登录时已先经 resolveDeeplinkTaskId 换成任务id。 */}
               <Route
-                path="plan-task/plan-task-action/agent/:agent_id/chats/:thread_id"
+                path="plan-task/plan-task-action/agent/:agent_id/chats"
                 element={
-                  <TaskEmbeddedAgentChat taskBase="/page/strategy/task-management/plan-task/plan-task-action" />
+                  <TaskFxWorkspace taskBase="/page/strategy/task-management/plan-task/plan-task-action" business="xdfx" lite />
                 }
-              />
+              >
+                <Route
+                  index
+                  element={
+                    <TaskFxIndexResolver taskBase="/page/strategy/task-management/plan-task/plan-task-action" />
+                  }
+                />
+                <Route
+                  path=":thread_id"
+                  element={
+                    <TaskBindChat taskBase="/page/strategy/task-management/plan-task/plan-task-action" />
+                  }
+                />
+              </Route>
               <Route path="mnty-task-mechanism" element={<TaskTyFrom defaultPage="iframeXdty" title="XDTY任务" />} />
               <Route path="mnty-task-plan" element={<TaskTyFrom defaultPage="iframeFaty" title="方案TY任务" />} />
               <Route path="mnty-task-zsty" element={<TaskTyFrom defaultPage="iframeSysystem" title="XXTY任务" />} />
@@ -259,7 +292,7 @@ export default function StrategyRoutes() {
               path="agents/:agent_id/chats/:thread_id"
               element={
                 <ChatRuntime>
-                  <AgentChatPage />
+                  <AgentChatPage showAgentList />
                 </ChatRuntime>
               }
             />
@@ -351,6 +384,26 @@ export default function StrategyRoutes() {
                 )
               }
             />
+            <Route
+              path="admin/task-buttons"
+              element={
+                getStoredAuth()?.system_role === "admin" ? (
+                  <TaskButtonsPage />
+                ) : (
+                  <Navigate to="/page/workspace/chats/new" replace />
+                )
+              }
+            />
+            <Route
+              path="admin/roundtable-diagnostics"
+              element={
+                getStoredAuth()?.system_role === "admin" ? (
+                  <RoundtableDiagnosticsPage />
+                ) : (
+                  <Navigate to="/page/workspace/chats/new" replace />
+                )
+              }
+            />
             <Route
               path="admin/scheduled-tasks"
               element={

frontend-web/src/pages/TaskButtonsPage.tsx

@@ -0,0 +1,389 @@
+"use client";
+
+/**
+ * 按钮管理（仅 admin）：配置任务工作区（rwfx / 3qfx / xdfx，见 ``TaskFxWorkspace``）
+ * 左侧栏的可配置跳转按钮——改名称、改跳转方式与地址、启停、排序、增删。
+ *
+ * 全局共享、整体替换保存（``PUT /api/task-buttons``）。后端整张表为空时回退代码种子默认
+ * （rwfx 的 4 个历史按钮），此页首次进入也以种子回填工作副本，便于从当前行为起步。
+ * 见 [[task-buttons]]。
+ */
+
+import { useEffect, useMemo, useState } from "react";
+import { Navigate } from "react-router-dom";
+import { ArrowDown, ArrowUp, Download, MousePointerClick, Plus, Save, Trash2 } from "lucide-react";
+import { toast } from "sonner";
+
+import { Button } from "@/components/ui/button";
+import { Input } from "@/components/ui/input";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { Switch } from "@/components/ui/switch";
+import { cn } from "@/lib/utils";
+import { getStoredAuth } from "@/core/auth";
+import {
+  DEFAULT_TASK_DEEPLINK_CONFIG,
+  fetchTaskDeeplinkConfig,
+  type TaskDeeplinkConfig,
+} from "@/core/auth/task-deeplink-config";
+import {
+  TASK_BUSINESSES,
+  TASK_BUSINESS_TARGETS,
+  defaultTaskButtons,
+  type TaskBusiness,
+  type TaskButton,
+} from "@/core/auth/task-buttons";
+import { useTaskButtonActions, useTaskButtons } from "@/strategy-components/api/task-buttons";
+
+let _seq = 1;
+const newId = (b: TaskBusiness) => `${b}-custom-${Date.now()}-${_seq++}`;
+
+/** 归一化用于「脏」判断（按 id 排序后整体比较）。 */
+function serialize(rows: TaskButton[]): string {
+  return JSON.stringify([...rows].sort((a, b) => a.id.localeCompare(b.id)));
+}
+
+export default function TaskButtonsPage() {
+  const isAdmin = getStoredAuth()?.system_role === "admin";
+  const { data: serverButtons = [], isLoading } = useTaskButtons();
+  const { save } = useTaskButtonActions();
+
+  const [cfg, setCfg] = useState<TaskDeeplinkConfig>(() => DEFAULT_TASK_DEEPLINK_CONFIG);
+  useEffect(() => {
+    let alive = true;
+    void fetchTaskDeeplinkConfig().then((c) => {
+      if (alive) setCfg(c);
+    });
+    return () => {
+      alive = false;
+    };
+  }, []);
+
+  const [rows, setRows] = useState<TaskButton[]>([]);
+  const [loadedKey, setLoadedKey] = useState<string | null>(null);
+  const [tab, setTab] = useState<TaskBusiness>("rwfx");
+
+  // 服务端首次/变化时回填工作副本（空表回填种子默认）。以序列化值判定，避免覆盖未保存编辑。
+  const sourceKey = useMemo(() => serialize(serverButtons), [serverButtons]);
+  useEffect(() => {
+    if (sourceKey !== loadedKey) {
+      setRows(serverButtons.length > 0 ? serverButtons : defaultTaskButtons(cfg));
+      setLoadedKey(sourceKey);
+    }
+  }, [sourceKey, loadedKey, serverButtons, cfg]);
+
+  const tabRows = useMemo(
+    () => rows.filter((r) => r.business === tab).sort((a, b) => a.sortOrder - b.sortOrder),
+    [rows, tab],
+  );
+
+  const dirty = useMemo(() => serialize(rows) !== sourceKey, [rows, sourceKey]);
+
+  if (!isAdmin) return <Navigate to="/page/workspace/chats/new" replace />;
+
+  const update = (id: string, patch: Partial<TaskButton>) =>
+    setRows((rs) => rs.map((r) => (r.id === id ? { ...r, ...patch } : r)));
+
+  const removeRow = (id: string) => setRows((rs) => rs.filter((r) => r.id !== id));
+
+  const addRow = () => {
+    const maxSort = tabRows.reduce((m, r) => Math.max(m, r.sortOrder), -1);
+    setRows((rs) => [
+      ...rs,
+      {
+        id: newId(tab),
+        business: tab,
+        label: "新按钮",
+        linkType: "url",
+        target: "",
+        appendTaskId: true,
+        idParam: "id",
+        idKind: "task",
+        openMode: "blank",
+        enabled: true,
+        sortOrder: maxSort + 1,
+      },
+    ]);
+  };
+
+  const moveRow = (id: string, dir: "up" | "down") => {
+    const list = [...tabRows];
+    const i = list.findIndex((r) => r.id === id);
+    const j = dir === "up" ? i - 1 : i + 1;
+    if (i < 0 || j < 0 || j >= list.length) return;
+    [list[i], list[j]] = [list[j], list[i]];
+    const reordered = list.map((r, idx) => ({ ...r, sortOrder: idx }));
+    setRows((rs) => [...rs.filter((r) => r.business !== tab), ...reordered]);
+  };
+
+  const handleSave = async () => {
+    const payload = rows.map((r) => ({ ...r, label: r.label.trim() }));
+    try {
+      await save.mutateAsync(payload);
+      toast.success("已保存按钮配置");
+    } catch (e) {
+      toast.error(e instanceof Error ? e.message : "保存失败");
+    }
+  };
+
+  const importDefaults = (business?: TaskBusiness) => {
+    const have = new Set(rows.map((r) => r.id));
+    const adds = defaultTaskButtons(cfg)
+      .filter((d) => !business || d.business === business)
+      .filter((d) => !have.has(d.id));
+    if (!adds.length) {
+      toast.info("没有可导入的默认按钮");
+      return;
+    }
+    setRows((rs) => [...rs, ...adds]);
+    toast.success(`已导入 ${adds.length} 个默认按钮`);
+  };
+
+  return (
+    <div className="flex size-full min-h-0 flex-col overflow-hidden bg-background">
+      <div className="border-border/70 flex items-center justify-between gap-3 border-b px-5 py-4">
+        <div className="flex items-center gap-2">
+          <MousePointerClick className="h-5 w-5 text-[var(--color-main,#0062D9)]" />
+          <div>
+            <div className="text-foreground text-base font-semibold">按钮管理</div>
+            <div className="text-muted-foreground text-xs">
+              配置任务工作区底部「快捷跳转」栏的按钮（名称 / 跳转方式 / 地址 / 启停 / 排序）
+            </div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2">
+          <Button variant="outline" size="sm" onClick={() => importDefaults()}>
+            <Download className="h-4 w-4" /> 导入全部默认
+          </Button>
+          <Button size="sm" onClick={handleSave} disabled={!dirty || save.isPending}>
+            <Save className="h-4 w-4" /> {save.isPending ? "保存中…" : "保存"}
+          </Button>
+        </div>
+      </div>
+
+      {/* 业务 tab：每个 tab = 一个任务深链页面，明确区分三种页面的按钮 */}
+      <div className="border-border/70 flex items-stretch gap-2 border-b px-5 pt-3">
+        {TASK_BUSINESSES.map((b) => {
+          const count = rows.filter((r) => r.business === b.code).length;
+          const active = tab === b.code;
+          return (
+            <button
+              key={b.code}
+              type="button"
+              onClick={() => setTab(b.code)}
+              className={cn(
+                "flex min-w-[8.5rem] flex-col gap-0.5 rounded-t-lg border border-b-0 px-4 py-2 text-left transition-colors",
+                active
+                  ? "border-[var(--color-main,#0062D9)] bg-[var(--color-main,#0062D9)] text-white"
+                  : "border-border/70 text-muted-foreground hover:bg-muted bg-transparent",
+              )}
+            >
+              <span className="flex items-center gap-1.5 text-sm font-semibold">
+                {b.name}
+                <span
+                  className={cn(
+                    "rounded px-1.5 text-[11px] tabular-nums",
+                    active ? "bg-white/20" : "bg-muted-foreground/15",
+                  )}
+                >
+                  {count}
+                </span>
+              </span>
+              <span className={cn("text-[11px]", active ? "text-white/80" : "opacity-70")}>
+                ?goPath={b.goPath}
+              </span>
+            </button>
+          );
+        })}
+      </div>
+
+      {/* 当前页面说明 */}
+      {(() => {
+        const meta = TASK_BUSINESSES.find((b) => b.code === tab)!;
+        return (
+          <div className="border-border/70 bg-muted/40 text-muted-foreground border-b px-5 py-2 text-xs">
+            正在编辑「<span className="text-foreground font-medium">{meta.name}</span>
+            」页面的按钮 · {meta.desc} 下方按钮会显示在该页面底部的「快捷跳转」栏，从上到下对应栏内从左到右的顺序。
+          </div>
+        );
+      })()}
+
+      <div className="min-h-0 flex-1 overflow-y-auto p-5">
+        {isLoading ? (
+          <div className="text-muted-foreground text-sm">加载中…</div>
+        ) : tabRows.length === 0 ? (
+          <div className="text-muted-foreground flex flex-col items-center gap-3 rounded-md border border-dashed p-6 text-center text-sm">
+            该页面暂无按钮。可「导入该页面默认按钮」一键填充，或点下方「添加按钮」自定义。
+            <Button variant="outline" size="sm" onClick={() => importDefaults(tab)}>
+              <Download className="h-4 w-4" /> 导入该页面默认按钮
+            </Button>
+          </div>
+        ) : (
+          <div className="flex flex-col gap-3">
+            {tabRows.map((r, idx) => (
+              <div
+                key={r.id}
+                className="border-border/70 grid grid-cols-[1fr_auto] items-start gap-3 rounded-lg border bg-card/60 p-3"
+              >
+                <div className="flex flex-col gap-2">
+                  <div className="flex flex-wrap items-center gap-2">
+                    <label className="text-muted-foreground w-16 shrink-0 text-xs">名称</label>
+                    <Input
+                      value={r.label}
+                      onChange={(e) => update(r.id, { label: e.target.value })}
+                      placeholder="按钮名称"
+                      className="h-8 max-w-xs"
+                    />
+                    <label className="text-muted-foreground ml-2 shrink-0 text-xs">类型</label>
+                    <Select
+                      value={r.linkType}
+                      onValueChange={(v) => update(r.id, { linkType: v as TaskButton["linkType"] })}
+                    >
+                      <SelectTrigger className="h-8 w-36">
+                        <SelectValue />
+                      </SelectTrigger>
+                      <SelectContent>
+                        <SelectItem value="url">外部链接</SelectItem>
+                        <SelectItem value="business">切换业务</SelectItem>
+                        <SelectItem value="purpose">目的树弹框</SelectItem>
+                      </SelectContent>
+                    </Select>
+                  </div>
+
+                  <div className="flex flex-wrap items-center gap-2">
+                    <label className="text-muted-foreground w-16 shrink-0 text-xs">目标</label>
+                    {r.linkType === "purpose" ? (
+                      <span className="text-muted-foreground text-xs">
+                        点击弹出当前任务的「任务目的」表格，无需配置目标。
+                      </span>
+                    ) : r.linkType === "url" ? (
+                      <>
+                        <Input
+                          value={r.target}
+                          onChange={(e) => update(r.id, { target: e.target.value })}
+                          placeholder="https://…（跳转地址）"
+                          className="h-8 flex-1 min-w-[16rem]"
+                        />
+                        <label className="text-muted-foreground ml-2 flex shrink-0 items-center gap-1.5 text-xs">
+                          <Switch
+                            checked={r.appendTaskId}
+                            onCheckedChange={(v) => update(r.id, { appendTaskId: v })}
+                          />
+                          追加参数
+                        </label>
+                        {r.appendTaskId && (
+                          <div className="flex shrink-0 items-center gap-1 text-xs">
+                            <span className="text-muted-foreground">?</span>
+                            <Input
+                              value={r.idParam}
+                              onChange={(e) => update(r.id, { idParam: e.target.value })}
+                              placeholder="id"
+                              className="h-8 w-24"
+                              title="查询参数名（如 id / task_id）"
+                            />
+                            <span className="text-muted-foreground">=</span>
+                            {/* 行动分析(xdfx)：行动id 与任务id 不同，可选追加哪种；其它业务固定任务id */}
+                            {tab === "xdfx" ? (
+                              <Select
+                                value={r.idKind}
+                                onValueChange={(v) => update(r.id, { idKind: v as TaskButton["idKind"] })}
+                              >
+                                <SelectTrigger className="h-8 w-24">
+                                  <SelectValue />
+                                </SelectTrigger>
+                                <SelectContent>
+                                  <SelectItem value="task">任务id</SelectItem>
+                                  <SelectItem value="action">行动id</SelectItem>
+                                </SelectContent>
+                              </Select>
+                            ) : (
+                              <span className="text-muted-foreground">任务id</span>
+                            )}
+                          </div>
+                        )}
+                        <label className="text-muted-foreground ml-2 shrink-0 text-xs">打开方式</label>
+                        <Select
+                          value={r.openMode}
+                          onValueChange={(v) => update(r.id, { openMode: v as TaskButton["openMode"] })}
+                        >
+                          <SelectTrigger className="h-8 w-32" title="外链打开方式">
+                            <SelectValue />
+                          </SelectTrigger>
+                          <SelectContent>
+                            <SelectItem value="blank">新窗口</SelectItem>
+                            <SelectItem value="self">当前窗口</SelectItem>
+                          </SelectContent>
+                        </Select>
+                      </>
+                    ) : (
+                      <Select value={r.target} onValueChange={(v) => update(r.id, { target: v })}>
+                        <SelectTrigger className="h-8 w-48">
+                          <SelectValue placeholder="选择目标业务" />
+                        </SelectTrigger>
+                        <SelectContent>
+                          {TASK_BUSINESS_TARGETS.map((t) => (
+                            <SelectItem key={t.code} value={t.code}>
+                              {t.label}（{t.code}）
+                            </SelectItem>
+                          ))}
+                        </SelectContent>
+                      </Select>
+                    )}
+                  </div>
+                </div>
+
+                <div className="flex items-center gap-1">
+                  <label className="text-muted-foreground mr-1 flex items-center gap-1.5 text-xs">
+                    <Switch
+                      checked={r.enabled}
+                      onCheckedChange={(v) => update(r.id, { enabled: v })}
+                    />
+                    启用
+                  </label>
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    className="h-8 w-8"
+                    disabled={idx === 0}
+                    onClick={() => moveRow(r.id, "up")}
+                    title="上移"
+                  >
+                    <ArrowUp className="h-4 w-4" />
+                  </Button>
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    className="h-8 w-8"
+                    disabled={idx === tabRows.length - 1}
+                    onClick={() => moveRow(r.id, "down")}
+                    title="下移"
+                  >
+                    <ArrowDown className="h-4 w-4" />
+                  </Button>
+                  <Button
+                    variant="ghost"
+                    size="icon"
+                    className="text-muted-foreground hover:text-destructive h-8 w-8"
+                    onClick={() => removeRow(r.id)}
+                    title="删除"
+                  >
+                    <Trash2 className="h-4 w-4" />
+                  </Button>
+                </div>
+              </div>
+            ))}
+          </div>
+        )}
+
+        <Button variant="outline" size="sm" className="mt-4" onClick={addRow}>
+          <Plus className="h-4 w-4" /> 添加按钮
+        </Button>
+      </div>
+    </div>
+  );
+}

frontend-web/src/pages/WorkspaceRoutes.tsx

@@ -288,7 +288,7 @@ export default function WorkspaceRoutes({
           element={
             <WorkspaceLayout {...layoutProps}>
               <ChatRuntime>
-                <AgentChatPage />
+                <AgentChatPage showAgentList />
               </ChatRuntime>
             </WorkspaceLayout>
           }

frontend-web/src/roundtable-planning/api/chains.ts

@@ -31,6 +31,8 @@ export interface ChainCreatePayload {
   coordinatorPrompt?: string | null;
   /** 默认席位执行模式（flash/thinking/pro/ultra）；null = 未设。 */
   seatMode?: SeatMode | null;
+  /** 研讨前并行取数开关（逐条 opt-in）；缺省 false。 */
+  gatherFirst?: boolean;
 }
 
 /** Partial update — send only what changed. */
@@ -46,12 +48,19 @@ export interface ChainUpdatePayload {
   coordinatorPrompt?: string | null;
   /** 默认席位执行模式；send `null` to clear, omit to leave. */
   seatMode?: SeatMode | null;
+  /** 研讨前并行取数开关；send true/false 改，omit 不改。 */
+  gatherFirst?: boolean;
   /** 发布开关：true 发布为公共 / false 取消发布；omit 不改。仅 owner 生效。 */
   isPublic?: boolean;
 }
 
-/** 列表筛选范围：`mine` = 我的；`public` = 所有已发布的公共链条。 */
-export type ChainScope = "mine" | "public";
+/**
+ * 列表筛选范围：
+ *  - `mine` = 我的；
+ *  - `public` = 所有已发布的公共链条；
+ *  - `all` = 所有账号的全部链条（**仅管理员**；后端对非管理员请求 `all` 退化为 `mine`）。
+ */
+export type ChainScope = "mine" | "public" | "all";
 
 const BASE = () => `${getBackendBaseURL()}/api/roundtable-chains`;
 
@@ -76,6 +85,7 @@ interface ServerChain {
   stage_goals?: (string | null)[] | null;
   coordinator_prompt?: string | null;
   seat_mode?: string | null;
+  gather_first?: boolean;
   is_public?: boolean;
   is_mine?: boolean;
   owner_name?: string | null;
@@ -93,6 +103,7 @@ function toChain(s: ServerChain): BusinessChain {
     stageGoals: Array.isArray(s.stage_goals) ? s.stage_goals : null,
     coordinatorPrompt: s.coordinator_prompt ?? null,
     seatMode: (s.seat_mode as SeatMode | null) ?? undefined,
+    gatherFirst: s.gather_first ?? false,
     isPublic: s.is_public ?? false,
     // 后端缺省时按「我的」处理(向后兼容旧响应)。
     isMine: s.is_mine ?? true,
@@ -112,6 +123,7 @@ function fromCreate(p: ChainCreatePayload) {
     ...(p.stageGoals !== undefined ? { stage_goals: p.stageGoals } : {}),
     ...(p.coordinatorPrompt !== undefined ? { coordinator_prompt: p.coordinatorPrompt } : {}),
     ...(p.seatMode !== undefined ? { seat_mode: p.seatMode } : {}),
+    ...(p.gatherFirst !== undefined ? { gather_first: p.gatherFirst } : {}),
   };
 }
 
@@ -126,6 +138,7 @@ function fromUpdate(p: ChainUpdatePayload) {
   if (p.stageGoals !== undefined) out.stage_goals = p.stageGoals;
   if (p.coordinatorPrompt !== undefined) out.coordinator_prompt = p.coordinatorPrompt;
   if (p.seatMode !== undefined) out.seat_mode = p.seatMode;
+  if (p.gatherFirst !== undefined) out.gather_first = p.gatherFirst;
   if (p.isPublic !== undefined) out.is_public = p.isPublic;
   return out;
 }
@@ -138,7 +151,7 @@ function fromUpdate(p: ChainUpdatePayload) {
  *  - `"public"`：所有已发布的公共链条（任何账号可见 / 可选入研讨）。
  */
 export async function listChains(scope: ChainScope = "mine"): Promise<BusinessChain[]> {
-  const url = scope === "public" ? `${BASE()}?scope=public` : BASE();
+  const url = scope === "mine" ? BASE() : `${BASE()}?scope=${scope}`;
   const res = await apiFetch(url, { method: "GET" });
   const data = await readJson<{ chains: ServerChain[] }>(res, "list chains");
   return (data.chains ?? []).map(toChain);

frontend-web/src/roundtable-planning/api/dashboard-sessions.ts

@@ -0,0 +1,68 @@
+/**
+ * 大屏绘制智能体「独立页面」会话持久化 —— 按外部 taskId 存取（后端不按 user 分权）。
+ *
+ * 一个 taskId 一条会话：聊天记录（transcript）+ 最新结构化数据（reportJson）。
+ * 后端 `/api/dashboard-sessions/by-task/{taskId}`（GET 取 / PUT upsert）。
+ * 详见后端 `app/gateway/routers/dashboard_sessions.py`。
+ */
+import { apiFetch } from "@/core/api/fetch-client";
+import { getBackendBaseURL } from "@/core/config";
+
+export interface DashboardSession {
+  taskId: string;
+  /** 聊天记录（大屏绘制智能体对话气泡数组；形状与 Step2Dialogue 一致，宽松存取）。 */
+  transcript: unknown[] | null;
+  /** 最新结构化数据（report-json 字符串）；可被 parseReportJson 解析则视为「有效结果」。 */
+  reportJson: string | null;
+  updatedAt: string | null;
+}
+
+interface ServerDashboardSession {
+  task_id: string;
+  transcript: unknown[] | null;
+  report_json: string | null;
+  created_at?: string | null;
+  updated_at?: string | null;
+}
+
+const BASE = () => `${getBackendBaseURL()}/api/dashboard-sessions`;
+
+function toClient(s: ServerDashboardSession): DashboardSession {
+  return {
+    taskId: s.task_id,
+    transcript: Array.isArray(s.transcript) ? s.transcript : null,
+    reportJson: s.report_json ?? null,
+    updatedAt: s.updated_at ?? null,
+  };
+}
+
+/** 取该 taskId 的会话；无（404）返回 null。 */
+export async function getDashboardSessionByTask(taskId: string): Promise<DashboardSession | null> {
+  const res = await apiFetch(`${BASE()}/by-task/${encodeURIComponent(taskId)}`, { method: "GET" });
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`get dashboard session failed (${res.status}): ${text}`);
+  }
+  return toClient((await res.json()) as ServerDashboardSession);
+}
+
+/** upsert 该 taskId 的会话（只传需要更新的字段）。 */
+export async function putDashboardSessionByTask(
+  taskId: string,
+  patch: { transcript?: unknown[]; reportJson?: string | null },
+): Promise<DashboardSession | null> {
+  const body: Record<string, unknown> = {};
+  if (patch.transcript !== undefined) body.transcript = patch.transcript;
+  if (patch.reportJson !== undefined) body.report_json = patch.reportJson;
+  const res = await apiFetch(`${BASE()}/by-task/${encodeURIComponent(taskId)}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`put dashboard session failed (${res.status}): ${text}`);
+  }
+  return toClient((await res.json()) as ServerDashboardSession);
+}

frontend-web/src/roundtable-planning/api/diagnostics-report.ts

@@ -0,0 +1,90 @@
+/**
+ * 会商「前端调用报错」上报器。
+ *
+ * 服务端诊断只能记到「处理函数跑起来后抛的错」；而用户实际遇到的很多报错（nginx/网关
+ * 返回 502、网络中断、fetch 直接失败、SSE 里收到的 error 帧）发生在**客户端**侧。这里把
+ * 这些前端可观测到的报错 best-effort 上报到 `POST /api/roundtable-diagnostics/report`
+ * （scope="client"，非 admin 接口），便于管理员在诊断页统一筛选用户使用时的报错。
+ *
+ * 设计：fire-and-forget + `keepalive`（页面跳转也能发出去）+ 绝不抛错（上报失败就算了，
+ * 不能让「报错上报」本身再影响会商流程）。
+ */
+
+import { apiFetch } from "@/core/api/fetch-client";
+import { getBackendBaseURL } from "@/core/config";
+
+export interface RoundtableErrorReport {
+  stage: string;
+  event: string;
+  message: string;
+  level?: "error" | "warning" | "info";
+  detail?: unknown;
+  agentId?: string;
+  agentName?: string;
+  cycle?: number;
+  draftId?: string;
+  taskId?: string;
+  jobId?: string;
+  httpStatus?: number;
+}
+
+// 页面级上下文（draftId / taskId），由会商页设置，使每条上报都能归属到草稿/任务，
+// 而无需把它们穿进每个底层 api 调用。
+let _ctx: { draftId?: string; taskId?: string } = {};
+
+export function setRoundtableErrorContext(ctx: { draftId?: string; taskId?: string }): void {
+  _ctx = { ..._ctx, ...ctx };
+}
+
+/** 据 agentType + agentName 推断诊断 stage（与后端 `_stage_for_agent` 对齐）。 */
+export function stageForRoundtableAgent(
+  agentType: string | undefined,
+  agentName: string | null | undefined,
+): string {
+  switch (agentName) {
+    case "roundtable-report":
+      return "step3_report";
+    case "roundtable-summary":
+      return "step3_summary";
+    case "roundtable-dashboard":
+      return "step3_dashboard";
+    case "roundtable-structure":
+      return "step3_structure";
+    default:
+      return agentType === "leader" ? "step2_leader" : "step2_seat";
+  }
+}
+
+export function reportRoundtableError(input: RoundtableErrorReport): void {
+  try {
+    const detail =
+      input.httpStatus != null && typeof input.detail !== "object"
+        ? { httpStatus: input.httpStatus, raw: input.detail }
+        : input.httpStatus != null
+          ? { httpStatus: input.httpStatus, ...(input.detail as Record<string, unknown>) }
+          : input.detail;
+    const body = JSON.stringify({
+      stage: input.stage,
+      event: input.event,
+      level: input.level ?? "error",
+      message: (input.message ?? "").slice(0, 2000),
+      detail,
+      jobId: input.jobId,
+      draftId: input.draftId ?? _ctx.draftId,
+      taskId: input.taskId ?? _ctx.taskId,
+      agentId: input.agentId,
+      agentName: input.agentName,
+      cycle: input.cycle,
+    });
+    void apiFetch(`${getBackendBaseURL()}/api/roundtable-diagnostics/report`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body,
+      keepalive: true,
+    }).catch(() => {
+      /* 上报失败静默 */
+    });
+  } catch {
+    /* 绝不抛错 */
+  }
+}

frontend-web/src/roundtable-planning/api/drafts.ts

@@ -133,6 +133,18 @@ export interface DraftStep3Snapshot {
    * 与经典 `html`（模式一）并存互不覆盖。后台挂起与手动并行绘制都写这里。Optional.
    */
   dashboardJson?: string | null;
+  /**
+   * 第三步「结果绘制(经典 HTML 看板)」生成过程的完整对话气泡（中间文字 + 步骤条），与第二步
+   * `step2RoundtableDialogues` 同形（`Step2Dialogue[]`）。存它使加载后能回显整段绘制过程，而非
+   * 只有最终 HTML。Optional —— 旧草稿没有该字段，恢复时回退为重建单条「历史记录」气泡。
+   */
+  reportDialogues?: unknown[];
+  /** 经典看板各席位 write_file 调用重建的 stub（threadId → [stub ai message]），供加载后点开产物预览。 */
+  reportSeatStubMessages?: Record<string, unknown[]>;
+  /** 第三步「大屏多页」生成过程的完整对话气泡（中间文字 + 步骤条），同 `reportDialogues`。Optional。 */
+  dashboardDialogues?: unknown[];
+  /** 大屏各席位 write_file 调用重建的 stub。Optional。 */
+  dashboardSeatStubMessages?: Record<string, unknown[]>;
 }
 
 /**
@@ -152,6 +164,20 @@ export interface DraftStep3SummarySnapshot {
   model: string;
   /** The agent's closing chat text (the report body it echoed into the conversation). */
   closing?: string;
+  /**
+   * 第三步「总结报告」生成过程的**完整对话气泡**（含中间文字内容 + 每条气泡的步骤条
+   * `steps`），与第二步 `step2RoundtableDialogues` 同形（`Step2Dialogue[]`）。存它使加载
+   * 草稿后能像第二步一样回显整段研讨过程，而不只是最终 md / 流程图。Optional —— 此前
+   * 的草稿没有该字段，恢复时回退为重建单条「历史记录」气泡。
+   */
+  dialogues?: unknown[];
+  /** 各席位 write_file 调用重建的 stub（threadId → [stub ai message]），供加载后点开产物的虚拟预览。 */
+  seatStubMessages?: Record<string, unknown[]>;
+  /**
+   * 入库状态（idle/asking/running/done/later/declined）。存它使重载草稿后不重复询问
+   * 已入库/已选稍后的会商；恢复展示用。Optional —— 旧草稿无该字段。
+   */
+  ingestStatus?: string;
 }
 
 /** Lightweight metadata row returned by the list endpoint. */
@@ -206,7 +232,7 @@ export interface DraftUpdatePayload {
 
 const BASE = () => `${getBackendBaseURL()}/api/roundtable-drafts`;
 
-async function readJson<T>(res: Response, ctx: string): Promise<T> {
+export async function readJson<T>(res: Response, ctx: string): Promise<T> {
   if (!res.ok) {
     const text = await res.text().catch(() => "");
     throw new Error(`${ctx} failed (${res.status}): ${text}`);
@@ -217,8 +243,9 @@ async function readJson<T>(res: Response, ctx: string): Promise<T> {
 // ── server ⇄ client field mapping ──────────────────────────────────────────
 // Backend uses snake_case (furthest_step / created_at / updated_at); the rest
 // of the frontend reads camelCase. Map at this boundary so callers stay clean.
+// Shared with the task-scoped client (`task-drafts.ts`) — same wire shape.
 
-interface ServerDraftMeta {
+export interface ServerDraftMeta {
   id: string;
   task_id?: string | null;
   title: string;
@@ -229,13 +256,13 @@ interface ServerDraftMeta {
   job_id?: string | null;
 }
 
-interface ServerDraftFull extends ServerDraftMeta {
+export interface ServerDraftFull extends ServerDraftMeta {
   step1: DraftStep1Snapshot | null;
   step2: DraftStep2Snapshot | null;
   step3: DraftStep3Snapshot | null;
 }
 
-function toMeta(s: ServerDraftMeta): DraftMeta {
+export function toMeta(s: ServerDraftMeta): DraftMeta {
   const step = Math.min(3, Math.max(1, s.furthest_step || 1)) as 1 | 2 | 3;
   return {
     id: s.id,
@@ -249,7 +276,7 @@ function toMeta(s: ServerDraftMeta): DraftMeta {
   };
 }
 
-function toRecord(s: ServerDraftFull): DraftRecord {
+export function toRecord(s: ServerDraftFull): DraftRecord {
   return {
     ...toMeta(s),
     step1: s.step1 ?? null,
@@ -258,7 +285,7 @@ function toRecord(s: ServerDraftFull): DraftRecord {
   };
 }
 
-function fromCreate(p: DraftCreatePayload) {
+export function fromCreate(p: DraftCreatePayload) {
   return {
     ...(p.id ? { id: p.id } : {}),
     ...(p.taskId ? { task_id: p.taskId } : {}),
@@ -270,7 +297,7 @@ function fromCreate(p: DraftCreatePayload) {
   };
 }
 
-function fromUpdate(p: DraftUpdatePayload) {
+export function fromUpdate(p: DraftUpdatePayload) {
   const out: Record<string, unknown> = {};
   if (p.title !== undefined) out.title = p.title;
   if (p.furthestStep !== undefined) out.furthest_step = p.furthestStep;
@@ -298,27 +325,6 @@ export async function getDraft(id: string): Promise<DraftRecord | null> {
   return toRecord(data);
 }
 
-/**
- * 按外部任务 id 取最新一条草稿（后端忽略 user，不分权）。无则返回 null（404）。
- * 无界嵌入抽屉打开时用于「该任务有聊天记录则回显最新一条」。
- */
-export async function getLatestDraftByTask(taskId: string): Promise<DraftRecord | null> {
-  const res = await apiFetch(`${BASE()}/by-task/${encodeURIComponent(taskId)}/latest`, { method: "GET" });
-  if (res.status === 404) return null;
-  const data = await readJson<ServerDraftFull>(res, "get latest draft by task");
-  return toRecord(data);
-}
-
-/**
- * 按外部任务 id 列出该任务全部草稿（轻量 meta，newest first；后端忽略 user，不分权）。
- * taskId 深链模式下历史下拉用：一个 taskId 可有多条会商记录。
- */
-export async function listDraftsByTask(taskId: string): Promise<DraftMeta[]> {
-  const res = await apiFetch(`${BASE()}/by-task/${encodeURIComponent(taskId)}`, { method: "GET" });
-  const data = await readJson<{ drafts: ServerDraftMeta[] }>(res, "list drafts by task");
-  return (data.drafts ?? []).map(toMeta);
-}
-
 export async function createDraft(payload: DraftCreatePayload): Promise<DraftRecord> {
   const res = await apiFetch(BASE(), {
     method: "POST",

frontend-web/src/roundtable-planning/api/flow-extract.ts

@@ -0,0 +1,188 @@
+/**
+ * Step3 流程图「后端抽取 + 校验」SSE 客户端。
+ *
+ * 对应后端 `POST /api/flow-extract/stream`：后端独立调模型(不走总结线程，避开 coordinatorPrompt
+ * 的报告锚定)两段式产图——①流式抽取 flow-json（实时吐回，前端原样显示给用户看）→ ②模型校验/修复
+ * → 返回校验后的结构化图数据 `{title, nodes, edges}`。
+ *
+ * 这样把不稳定的「文本→结构」抽取 + 校验放后端，前端只负责实时显示抽取过程 + 拿最终图绘制。
+ */
+import { apiFetch } from "@/core/api/fetch-client";
+import { getBackendBaseURL } from "@/core/config";
+import type { FlowGraphData } from "@/roundtable-planning/lib/flow-graph";
+
+/** 第三步输入框意图分类结果（与后端 /intent 对应）。 */
+export type FlowIntent = "regenerate_report" | "modify_flow" | "regenerate_flow" | "ingest" | "qa" | "unclear";
+
+/**
+ * 识别第三步输入框消息的意图（一次模型调用）。失败回退 "unclear"（前端发起澄清）。
+ * 参考 ai_writing 的一次性 JSON 意图识别范式。
+ */
+export async function classifyFlowIntent(req: {
+  message: string;
+  hasReport: boolean;
+  hasFlow: boolean;
+  /** 当前是否可入库（入库按钮已出现、未入库）；为真才允许识别出 ingest 意图。 */
+  canIngest?: boolean;
+  model?: string;
+  signal?: AbortSignal;
+}): Promise<{ intent: FlowIntent; reason: string }> {
+  try {
+    const res = await apiFetch(`${getBackendBaseURL()}/api/flow-extract/intent`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        message: req.message,
+        has_report: req.hasReport,
+        has_flow: req.hasFlow,
+        can_ingest: req.canIngest ?? false,
+        model: req.model,
+      }),
+      signal: req.signal,
+    });
+    if (!res.ok) return { intent: "unclear", reason: "" };
+    const data = (await res.json()) as { intent?: string; reason?: string };
+    const intent = (data.intent ?? "unclear") as FlowIntent;
+    return { intent, reason: data.reason ?? "" };
+  } catch {
+    return { intent: "unclear", reason: "" };
+  }
+}
+
+/** 「稍后入库」待命时输入框消息的入库意图（与后端 /ingest-intent 对应）。 */
+export type IngestIntent = "start_ingest" | "add_data" | "other" | "unclear";
+
+/**
+ * 识别「稍后入库」后用户在输入框的入库意图（一次模型调用）。
+ * 失败回退 "unclear"（前端发起协助让用户自己选）。
+ */
+export async function classifyIngestIntent(req: {
+  message: string;
+  model?: string;
+  signal?: AbortSignal;
+}): Promise<{ intent: IngestIntent; reason: string }> {
+  try {
+    const res = await apiFetch(`${getBackendBaseURL()}/api/flow-extract/ingest-intent`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ message: req.message, model: req.model }),
+      signal: req.signal,
+    });
+    if (!res.ok) return { intent: "unclear", reason: "" };
+    const data = (await res.json()) as { intent?: string; reason?: string };
+    return { intent: (data.intent ?? "unclear") as IngestIntent, reason: data.reason ?? "" };
+  } catch {
+    return { intent: "unclear", reason: "" };
+  }
+}
+
+export interface FlowExtractRequest {
+  /** 报告 Markdown（优先数据来源）。 */
+  reportMd?: string | null;
+  /** 各席位交付（无报告时的数据来源）。 */
+  seatDeliveries?: Array<{ sender: string; content: string }>;
+  /** 业务链层级（stages 的 goal）。 */
+  chainLevels?: string[];
+  /** 业务链总控编排提示（写明层级时优先用它）。 */
+  coordinatorPrompt?: string | null;
+  /** 深链接业务码（rwfx→6BF 等）。非空 → 后端按业务链抽取规范强制注入完整层级。 */
+  businessCode?: string | null;
+  /** 根节点 label 强制值（xdfx：本次行动名称）。非空 → 根节点 n1 用它，不用任务名当根。 */
+  rootLabel?: string | null;
+  /** 推理模型名（沿用第三步所选）。 */
+  model?: string;
+  /** Phase 2 问答修改：当前流程图 + 指令 → 按指令改图（其余不变）。 */
+  currentGraph?: FlowGraphData | null;
+  instruction?: string;
+  signal?: AbortSignal;
+  /** 抽取流式增量（含 `<think>` 思考 + 正文 + JSON，前端原样渲染：思考块 + 代码块）。 */
+  onExtractDelta?: (text: string) => void;
+  /** 抽取结束、进入校验阶段。 */
+  onValidating?: () => void;
+  /** 校验/修复流式增量（同样含思考 + 正文，前端实时显示校验过程）。 */
+  onValidateDelta?: (text: string) => void;
+  /**
+   * 模型自动容错：后端某模型抽取失败，已切到下一个模型重抽。上层据此**清空已累计的抽取增量**
+   * （`onExtractDelta` 之前吐出的半截内容）并提示用户。`failedModel`/`nextModel`/`reason` 描述切换。
+   */
+  onModelSwitch?: (info: { failedModel: string; nextModel: string; reason: string }) => void;
+}
+
+/**
+ * 消费 SSE，返回校验后的最终图。抽取阶段通过 `onExtractDelta` 实时回吐；
+ * 出错（后端 error 帧 / 网络）抛异常。
+ */
+export async function streamFlowExtract(req: FlowExtractRequest): Promise<FlowGraphData> {
+  const res = await apiFetch(`${getBackendBaseURL()}/api/flow-extract/stream`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      report_md: req.reportMd ?? null,
+      seat_deliveries: (req.seatDeliveries ?? []).map((s) => ({ sender: s.sender, content: s.content })),
+      chain_levels: req.chainLevels ?? [],
+      coordinator_prompt: req.coordinatorPrompt ?? null,
+      business_code: req.businessCode ?? null,
+      root_label: req.rootLabel ?? null,
+      model: req.model,
+      current_graph: req.currentGraph ?? null,
+      instruction: req.instruction ?? null,
+    }),
+    signal: req.signal,
+  });
+  if (!res.ok || !res.body) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`flow-extract failed (${res.status}): ${text}`);
+  }
+
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  let graph: FlowGraphData | null = null;
+  let errored: string | null = null;
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split("\n");
+    buffer = lines.pop() ?? "";
+    for (const rawLine of lines) {
+      const line = rawLine.trimEnd();
+      if (!line.startsWith("data:")) continue;
+      const data = line.slice(5).trim();
+      if (!data) continue;
+      let frame: Record<string, unknown>;
+      try {
+        frame = JSON.parse(data) as Record<string, unknown>;
+      } catch {
+        continue;
+      }
+      const event = typeof frame.event === "string" ? frame.event : "";
+      if (event === "extract_delta") {
+        const c = typeof frame.content === "string" ? frame.content : "";
+        if (c) req.onExtractDelta?.(c);
+      } else if (event === "validating") {
+        req.onValidating?.();
+      } else if (event === "validate_delta") {
+        const c = typeof frame.content === "string" ? frame.content : "";
+        if (c) req.onValidateDelta?.(c);
+      } else if (event === "model_switch") {
+        req.onModelSwitch?.({
+          failedModel: typeof frame.failed_model === "string" ? frame.failed_model : "",
+          nextModel: typeof frame.next_model === "string" ? frame.next_model : "",
+          reason: typeof frame.reason === "string" ? frame.reason : "",
+        });
+      } else if (event === "final") {
+        graph = (frame.graph as FlowGraphData) ?? null;
+      } else if (event === "error") {
+        errored = typeof frame.detail === "string" ? frame.detail : "未知错误";
+      }
+    }
+  }
+
+  if (errored) throw new Error(errored);
+  if (!graph || !Array.isArray(graph.nodes) || graph.nodes.length === 0) {
+    throw new Error("flow-extract 未返回有效流程图");
+  }
+  return graph;
+}

frontend-web/src/roundtable-planning/api/ingest.ts

@@ -0,0 +1,58 @@
+/**
+ * 第三步「入库」功能门控 + 入库执行客户端。
+ *
+ * 入库不再由前端硬编码「有没有含『入库』关键字的技能」判定，而是让**结构化输出智能体**
+ * （`roundtable-structure`）读它挂载的入库技能 + 当前业务场景，**自行判断**是否有适合本
+ * 场景的入库技能（技能名可能含「六步法」等场景线索）。判定为可入库才显示「入库」按钮。
+ *
+ * 真正入库时，由结构化输出智能体走**完整 agent 运行时**(`POST /api/multi-agent/run/stream`,
+ * role=ingest)**自己挑技能、读 SKILL.md 并调用**完成入库——而不是前端代它调技能。
+ */
+import { apiFetch } from "@/core/api/fetch-client";
+import { getBackendBaseURL } from "@/core/config";
+
+/** `/ingest-eligibility` 返回：是否可入库 + 选中的技能名 + 一句话依据。 */
+export interface IngestEligibility {
+  canIngest: boolean;
+  skill: string;
+  reason: string;
+}
+
+/**
+ * 让结构化输出智能体判断「当前业务场景**是否有合适的入库技能**」（决定是否显示入库按钮）。
+ *
+ * 入参为业务场景线索（业务码 / 业务链名 / 总控编排提示 / 方案标题）+ taskId，由后端把挂在
+ * `roundtable-structure` 上、且已启用的技能交给模型对照判断。失败 / 未配置入库技能 → 不可入库。
+ */
+export async function checkIngestEligibility(req: {
+  taskId?: string | null;
+  businessCode?: string | null;
+  chainName?: string | null;
+  coordinatorPrompt?: string | null;
+  reportTitle?: string | null;
+  model?: string;
+}): Promise<IngestEligibility> {
+  try {
+    const res = await apiFetch(`${getBackendBaseURL()}/api/flow-extract/ingest-eligibility`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        task_id: req.taskId ?? null,
+        business_code: req.businessCode ?? null,
+        chain_name: req.chainName ?? null,
+        coordinator_prompt: req.coordinatorPrompt ?? null,
+        report_title: req.reportTitle ?? null,
+        model: req.model,
+      }),
+    });
+    if (!res.ok) return { canIngest: false, skill: "", reason: "" };
+    const data = (await res.json()) as { can_ingest?: boolean; skill?: string; reason?: string };
+    return {
+      canIngest: !!data.can_ingest,
+      skill: data.skill ?? "",
+      reason: data.reason ?? "",
+    };
+  } catch {
+    return { canIngest: false, skill: "", reason: "" };
+  }
+}

frontend-web/src/roundtable-planning/api/intent.ts

@@ -2,6 +2,7 @@ import { apiFetch } from "@/core/api/fetch-client";
 import { getBackendBaseURL } from "@/core/config";
 
 import type { ClarificationPayload } from "./multi-agent";
+import { reportRoundtableError } from "./diagnostics-report";
 import { resolveAllowMultiple } from "@/roundtable-planning/lib/clarification";
 
 export type { ClarificationPayload };
@@ -340,6 +341,11 @@ export async function streamIntent(req: StreamIntentRequest): Promise<StreamInte
 
   if (!res.ok || !res.body) {
     const text = await res.text().catch(() => "");
+    reportRoundtableError({
+      stage: "step1_intent", event: "intent_stream_http_error",
+      message: `第一步意图生成失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status,
+    });
     throw new Error(`intent/stream failed (${res.status}): ${text}`);
   }
 
@@ -425,6 +431,11 @@ export async function streamIntent(req: StreamIntentRequest): Promise<StreamInte
         }
         if (parsed.status === "error") {
           result.errorDetail = parseIntentErrorDetail(parsed.error_detail);
+          reportRoundtableError({
+            stage: "step1_intent", event: "intent_error_frame",
+            message: `第一步意图生成报错：${(result.content || "").slice(0, 800)}`,
+            detail: result.errorDetail,
+          });
         }
         if (parsed.status === "clarification" && result.clarifications.length === 0) {
           // Fallback path: no live `type:"tool"` clarification frames were seen

frontend-web/src/roundtable-planning/api/multi-agent.ts

@@ -2,6 +2,7 @@ import { apiFetch } from "@/core/api/fetch-client";
 import { getBackendBaseURL } from "@/core/config";
 
 import { resolveAllowMultiple } from "@/roundtable-planning/lib/clarification";
+import { reportRoundtableError, stageForRoundtableAgent } from "@/roundtable-planning/api/diagnostics-report";
 
 export type ThreadIdMap = Record<string, string>;
 
@@ -74,6 +75,12 @@ export async function initMultiAgent(
   tlog(`fetch.headers status=${res.status}`);
   if (!res.ok || !res.body) {
     const text = await res.text().catch(() => "");
+    reportRoundtableError({
+      stage: "step2_init", event: "init_http_error",
+      message: `第二步会商初始化失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status,
+      detail: { agentNames: payload.agentNames, mainAgentName: payload.mainAgentName },
+    });
     throw new Error(`init multi-agent failed (${res.status}): ${text}`);
   }
 
@@ -150,18 +157,34 @@ export async function initMultiAgent(
     }
   } catch (err) {
     aborted = (err as Error)?.name === "AbortError" || payload.signal?.aborted === true;
-    if (!aborted) throw err;
+    if (!aborted) {
+      reportRoundtableError({
+        stage: "step2_init", event: "init_stream_exception",
+        message: `第二步会商初始化中断（网络不可达 / 连接中断 / 超时）：${(err as Error)?.message ?? String(err)}`,
+        detail: { seatCount },
+      });
+      throw err;
+    }
   }
 
   tlog(`total ${(performance.now() - t0).toFixed(0)}ms (seats=${seatCount})`);
 
   if (errorDetail) {
+    reportRoundtableError({
+      stage: "step2_init", event: "init_error_frame",
+      message: `第二步会商初始化报错：${errorDetail.slice(0, 800)}`,
+    });
     throw new Error(`init multi-agent failed: ${errorDetail}`);
   }
   if (aborted) {
     throw new DOMException("init aborted", "AbortError");
   }
   if (!threadIds || !mainAgentName) {
+    reportRoundtableError({
+      stage: "step2_init", event: "init_incomplete",
+      message: "第二步会商初始化流提前结束（未收到 init_done，可能连接被中断）",
+      detail: { seatCount, hasThreadIds: !!threadIds, mainAgentName },
+    });
     throw new Error("init multi-agent stream ended without init_done");
   }
   return {
@@ -211,6 +234,17 @@ export interface StreamMultiAgentRequest {
   reasoningEffort?: "minimal" | "low" | "medium" | "high";
   /** 仅 special 用；ultra 档置真，给席位解锁 `task` 子代理工具。 */
   subagentEnabled?: boolean;
+  /**
+   * 仅 special 用。会商席位「技能识别强化」开关（沿用所选业务链条配置）。置 true 时后端把该
+   * 席位配置的技能（含 SKILL.md 路径 + 必须先 read_file 的硬指令）拼进本轮任务，补偿弱模型。
+   * 与该席位 agent 自身 config.yaml 的同名开关取 OR。省略 = false（关）。
+   */
+  seatSkillDirective?: boolean;
+  /**
+   * 深链接业务码（rwfx→6BF 等）。**仅方案总结报告(summary)单例消费**：非空 → 后端按业务链抽取规范
+   * 强制注入「完整性核对」指令，让总结核对产出相对业务链完不完整。普通会商省略 = 不注入。
+   */
+  businessCode?: string | null;
   skillStopNames?: string[];
   /**
    * 仅 leader 用。置 true 表示这是「派活后让总控判断继续/综合」的轮次:后端会把各已交付
@@ -263,6 +297,27 @@ export interface StreamMultiAgentRequest {
     name?: string,
     args?: Record<string, unknown>,
   ) => void;
+  /**
+   * 模型自动容错：后端检测到当前模型出问题（兜底错误文案 / 交付为空等），已自动切到下一个
+   * 模型并即将重跑本轮时触发。上层据此把该角色「正在流式的失败气泡」重置（清空已累计的增量
+   * 文本）并给用户一条「『X』模型异常，已切换『Y』继续」的提示。此回调可能多次触发（连续多个
+   * 模型都失败时）。触发后，本次 streamMultiAgent 仍会继续用新模型流式，最终照常 resolve。
+   */
+  onModelSwitch?: (info: ModelSwitchInfo) => void;
+}
+
+/** 模型自动容错通知（`streamMultiAgent` 的 `onModelSwitch` 回调入参）。 */
+export interface ModelSwitchInfo {
+  /** 角色：leader / seat / seat_parallel / report / summary / dashboard / ingest。 */
+  role: string;
+  /** 出问题的智能体 agent_name。 */
+  agentName: string;
+  /** 失败的模型名。 */
+  failedModel: string;
+  /** 已切换到的下一个模型名。 */
+  nextModel: string;
+  /** 失败原因（已翻译成简短中文，如「服务繁忙」）。 */
+  reason: string;
 }
 
 export interface ClarificationPayload {
@@ -296,6 +351,8 @@ export interface StreamMultiAgentResult {
   content: string;
   /** Echoed agent_name of the agent that produced this run. */
   agentName: string | null;
+  /** 实际产出本轮结果的模型（发生模型自动容错时即最终切换到的模型）；后端未下发时为 null。 */
+  modelUsed?: string | null;
   /**
    * Populated when the leader called ask_clarification — the run ended without
    * dispatching, and the model is asking the user a question instead. When
@@ -442,6 +499,11 @@ function extractAiTextDelta(parsed: unknown): { text: string; id: string } | nul
 export async function streamMultiAgent(
   req: StreamMultiAgentRequest,
 ): Promise<StreamMultiAgentResult> {
+  // 整段包一层兜底：除已在具体分支上报的（HTTP 错误 / error 帧 / worker error 事件）外，
+  // 再兜住 fetch 直接 reject（网络不可达 / 连接被拒）与流式中途中断（连接重置 / 超时），
+  // 做到「能收集到的报错越全越好」。`reported` 防止与具体分支重复上报。
+  let reported = false;
+  try {
   const res = await apiFetch(`${getBackendBaseURL()}/api/multi-agent/run/stream`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -457,6 +519,10 @@ export async function streamMultiAgent(
       thinking_enabled: req.thinkingEnabled,
       reasoning_effort: req.reasoningEffort,
       subagent_enabled: req.subagentEnabled,
+      // 仅 special 用;会商技能识别强化(沿用所选业务链条开关)。省略 → 后端按 false(关)处理。
+      seat_skill_directive: req.seatSkillDirective ?? false,
+      // 仅 summary 单例用;深链接业务码 → 后端注入业务链完整性核对。省略/空 → 不注入。
+      business_code: req.businessCode ?? null,
       skill_stop_names: req.skillStopNames ?? [],
       // 仅 leader 用;综合轮让后端注入各席位完整交付正文。省略 → 后端按 false 处理。
       synthesis_mode: req.synthesisMode ?? false,
@@ -474,6 +540,17 @@ export async function streamMultiAgent(
 
   if (!res.ok || !res.body) {
     const text = await res.text().catch(() => "");
+    // 用户实际遇到的报错（含进第三步常见的 502）：HTTP 层就失败、SSE 都没建起来。
+    reportRoundtableError({
+      stage: stageForRoundtableAgent(req.agentType, req.agentName),
+      event: "run_stream_http_error",
+      message: `「${req.displayName || req.agentName}」调用失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status,
+      agentId: req.agentName,
+      agentName: req.displayName || req.agentName,
+      detail: { agentType: req.agentType },
+    });
+    reported = true;
     throw new Error(`run/stream failed (${res.status}): ${text}`);
   }
 
@@ -501,6 +578,7 @@ export async function streamMultiAgent(
     content: "",
     agentName: null,
     clarification: null,
+    modelUsed: null,
   };
 
   // Inferred SSE phase + a tiny helper so we only fire onPhaseChange when the
@@ -611,6 +689,43 @@ export async function streamMultiAgent(
         frameSeq += 1;
         if (debugEnabled) console.debug(debugLabel, `frame#${frameSeq} event=${lastEvent}`, parsed);
 
+        // worker 把 run 内异常(常见：第二步席位/Step3 模型调用失败)发成 `event: error`
+        // SSE 帧 `{message,name}`——它既不是 HTTP 错误也不是 `{status:"error"}` 终帧，
+        // 单独在这里捕获上报，否则这类「模型没调用成功」的报错会漏收集。
+        if (lastEvent === "error") {
+          const obj = parsed && typeof parsed === "object" ? (parsed as Record<string, unknown>) : { raw: parsed };
+          reportRoundtableError({
+            stage: stageForRoundtableAgent(req.agentType, req.agentName),
+            event: "run_worker_error_event",
+            message: `「${req.displayName || req.agentName}」运行报错：${String(obj.message ?? obj.name ?? "").slice(0, 800)}`,
+            agentId: req.agentName,
+            agentName: req.displayName || req.agentName,
+            detail: { ...obj, agentType: req.agentType, framesBeforeError: frameSeq },
+          });
+        }
+
+        // 模型自动容错帧：后端检测到当前模型出问题，已切到下一个模型并即将重跑本轮。
+        // 不是终态帧（无 content）→ 不结束流。清空已累计的（失败尝试的）tool_call 增量，
+        // 把 phase 退回 connected，并通知上层重置该角色气泡 + 给用户提示。随后新模型的
+        // 流式增量会照常通过 onTextDelta 继续累计到（已被上层清空的）气泡。
+        if (
+          parsed &&
+          typeof parsed === "object" &&
+          (parsed as Record<string, unknown>).status === "model_switch"
+        ) {
+          const obj = parsed as Record<string, unknown>;
+          toolCallAcc.clear();
+          currentPhase = "connected";
+          req.onModelSwitch?.({
+            role: typeof obj.role === "string" ? obj.role : "",
+            agentName: typeof obj.agent_name === "string" ? obj.agent_name : req.agentName,
+            failedModel: typeof obj.failed_model === "string" ? obj.failed_model : "",
+            nextModel: typeof obj.next_model === "string" ? obj.next_model : "",
+            reason: typeof obj.reason === "string" ? obj.reason : "",
+          });
+          continue;
+        }
+
         // Phase inference from LangGraph messages-tuple frames. We only flip
         // to tool_calling/tool_result on chunks that clearly indicate them;
         // everything else with non-empty AI text means we're streaming.
@@ -711,6 +826,22 @@ export async function streamMultiAgent(
           if (typeof parsed.agent_name === "string") {
             result.agentName = parsed.agent_name;
           }
+          {
+            const mu = (parsed as Record<string, unknown>).model_used;
+            if (typeof mu === "string" && mu) result.modelUsed = mu;
+          }
+          // SSE error 帧（后端 stream_generator 在席位/Step3 run 失败时下发
+          // `{status:"error", content, agent_name}`）：上报，便于收集用户侧报错。
+          if (result.message === "error") {
+            reportRoundtableError({
+              stage: stageForRoundtableAgent(req.agentType, result.agentName || req.agentName),
+              event: "run_stream_error_frame",
+              message: `「${req.displayName || req.agentName}」运行报错：${(result.content || "").slice(0, 800)}`,
+              agentId: result.agentName || req.agentName,
+              agentName: req.displayName || req.agentName,
+              detail: { agentType: req.agentType, framesBeforeError: frameSeq },
+            });
+          }
           continue;
         }
 
@@ -728,6 +859,19 @@ export async function streamMultiAgent(
     console.debug(debugLabel, `stream ended after ${frameSeq} frames; final content length=${result.content.length}`);
   }
   return result;
+  } catch (err) {
+    if (!reported && req.signal?.aborted !== true && (err as Error)?.name !== "AbortError") {
+      reportRoundtableError({
+        stage: stageForRoundtableAgent(req.agentType, req.agentName),
+        event: "run_stream_exception",
+        message: `「${req.displayName || req.agentName}」调用异常（网络不可达 / 连接中断 / 超时）：${(err as Error)?.message ?? String(err)}`,
+        agentId: req.agentName,
+        agentName: req.displayName || req.agentName,
+        detail: { agentType: req.agentType },
+      });
+    }
+    throw err;
+  }
 }
 
 export interface SessionArtifactFile {
@@ -829,12 +973,48 @@ export async function initReportThread(
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
+    reportRoundtableError({
+      stage: "step3_report", event: "init_thread_http_error",
+      message: `结果绘制线程创建失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status, agentId: "roundtable-report", agentName: "结果绘制",
+    });
     throw new Error(`init report thread failed (${res.status}): ${text}`);
   }
   const json = (await res.json()) as { agent_name: string; thread_id: string };
   return { agentName: json.agent_name, threadId: json.thread_id };
 }
 
+/**
+ * Create a thread for the Step 3「大屏多页」dashboard-data agent
+ * (`roundtable-dashboard`, a built-in singleton — distinct from `roundtable-report`;
+ * its run policy disables ALL tools so it only emits a ```report-json block). Run it
+ * with {@link streamMultiAgent} (`agentType: "special"`, `agentName: "roundtable-dashboard"`,
+ * `dAgentThreadId: { [agentName]: threadId }`); the frontend then `extractReportData`s
+ * the streamed text. Follow-up Q&A / refinements reuse the SAME thread (do not re-init)
+ * so the agent keeps the prior dashboard context.
+ */
+export async function initDashboardThread(
+  options: { signal?: AbortSignal } = {},
+): Promise<ReportThreadResponse> {
+  const res = await apiFetch(`${getBackendBaseURL()}/api/multi-agent/dashboard/init`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: "{}",
+    signal: options.signal,
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    reportRoundtableError({
+      stage: "step3_dashboard", event: "init_thread_http_error",
+      message: `大屏页面线程创建失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status, agentId: "roundtable-dashboard", agentName: "大屏页面",
+    });
+    throw new Error(`init dashboard thread failed (${res.status}): ${text}`);
+  }
+  const json = (await res.json()) as { agent_name: string; thread_id: string };
+  return { agentName: json.agent_name, threadId: json.thread_id };
+}
+
 /**
  * Create a thread for the Step 3「总结报告」summary agent (`roundtable-summary`,
  * a built-in singleton — distinct from `roundtable-report`; this only spins up a
@@ -854,8 +1034,44 @@ export async function initSummaryThread(
   });
   if (!res.ok) {
     const text = await res.text().catch(() => "");
+    reportRoundtableError({
+      stage: "step3_summary", event: "init_thread_http_error",
+      message: `方案报告线程创建失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status, agentId: "roundtable-summary", agentName: "方案报告",
+    });
     throw new Error(`init summary thread failed (${res.status}): ${text}`);
   }
   const json = (await res.json()) as { agent_name: string; thread_id: string };
   return { agentName: json.agent_name, threadId: json.thread_id };
 }
+
+/**
+ * Create a thread for the Step 3「入库」structure agent (`roundtable-structure`,
+ * a built-in singleton — the same agent that extracts the flowchart, but this run
+ * uses the `ingest` run policy so its attached ingest skill actually executes).
+ * Run it afterwards with {@link streamMultiAgent} (`agentType: "special"`,
+ * `agentName: "roundtable-structure"`, `dAgentThreadId: { [agentName]: threadId }`):
+ * the agent picks the suitable ingest skill (its name may contain「六步法」), reads
+ * its SKILL.md and calls it — passing the taskId + summary report + structured flow.
+ */
+export async function initStructureThread(
+  options: { signal?: AbortSignal } = {},
+): Promise<ReportThreadResponse> {
+  const res = await apiFetch(`${getBackendBaseURL()}/api/multi-agent/structure/init`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: "{}",
+    signal: options.signal,
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    reportRoundtableError({
+      stage: "step3_structure", event: "init_thread_http_error",
+      message: `结构化输出线程创建失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status, agentId: "roundtable-structure", agentName: "结构化输出",
+    });
+    throw new Error(`init structure thread failed (${res.status}): ${text}`);
+  }
+  const json = (await res.json()) as { agent_name: string; thread_id: string };
+  return { agentName: json.agent_name, threadId: json.thread_id };
+}

frontend-web/src/roundtable-planning/api/recommend.ts

@@ -3,6 +3,7 @@ import { getBackendBaseURL } from "@/core/config";
 import type { Agent } from "@/core/agents";
 
 import type { IntentSummary } from "./intent";
+import { reportRoundtableError } from "./diagnostics-report";
 
 /**
  * Agent-recommendation API. Sits between Step 1 (intent clarification) and
@@ -318,6 +319,11 @@ export async function streamRecommend(req: StreamRecommendRequest): Promise<Stre
 
   if (!res.ok || !res.body) {
     const text = await res.text().catch(() => "");
+    reportRoundtableError({
+      stage: "step2_recommend", event: "recommend_stream_http_error",
+      message: `智能体推荐失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status,
+    });
     throw new Error(`recommend/stream failed (${res.status}): ${text}`);
   }
 
@@ -373,6 +379,12 @@ export async function streamRecommend(req: StreamRecommendRequest): Promise<Stre
         if (Array.isArray(parsed.picks)) {
           result.picks = parsed.picks as RecommendPick[];
         }
+        if (parsed.status === "error") {
+          reportRoundtableError({
+            stage: "step2_recommend", event: "recommend_error_frame",
+            message: `智能体推荐报错：${(result.content || "").slice(0, 800)}`,
+          });
+        }
         continue;
       }
 

frontend-web/src/roundtable-planning/api/roundtable-jobs.ts

@@ -15,6 +15,7 @@ import { apiFetch } from "@/core/api/fetch-client";
 import { getBackendBaseURL } from "@/core/config";
 
 import { getAvatarTypeFor } from "../lib/roundtable-constants";
+import { reportRoundtableError } from "./diagnostics-report";
 import { seatModeToRunParams } from "../lib/seat-mode";
 import {
   isTerminalJobStatus,
@@ -29,6 +30,11 @@ const BASE = () => `${getBackendBaseURL()}/api/roundtable-jobs`;
 async function readJson<T>(res: Response, ctx: string): Promise<T> {
   if (!res.ok) {
     const text = await res.text().catch(() => "");
+    reportRoundtableError({
+      stage: "job", event: "job_api_http_error",
+      message: `后台作业接口「${ctx}」失败 (HTTP ${res.status}): ${text.slice(0, 500)}`,
+      httpStatus: res.status,
+    });
     throw new Error(`${ctx} failed (${res.status}): ${text}`);
   }
   return (await res.json()) as T;
@@ -81,6 +87,8 @@ function toStartBody(p: StartJobPayload) {
   const seat = p.seatMode ? seatModeToRunParams(p.seatMode) : null;
   return {
     draftId: p.draftId ?? null,
+    // taskId 非空 → task 作业（按 task 共享、不分权，报告写回独立 task-draft 存储）。
+    ...(p.taskId ? { taskId: p.taskId } : {}),
     intent: p.intent,
     agents: p.agents,
     model: p.model,
@@ -90,6 +98,18 @@ function toStartBody(p: StartJobPayload) {
     seedMessage: p.seedMessage,
     threadIds: p.threadIds ?? null,
     coordinatorName: p.coordinatorName ?? "roundtable-coordinator",
+    // 每席位技能识别强化映射 {agentId: bool}：沿用所选业务链条里各席位的开关；缺省 {}。
+    // 后端 run_seat 按 agentId 查表，与各席位 agent 自身开关取 OR。
+    seat_skill_directives: p.seatSkillDirectives ?? {},
+    // 每席位推理深度覆盖映射 {agentId: SeatMode|null}：沿用所选业务链条里各席位单独配的推理深度；
+    // 后端 run_seat 按 agentId 查表，覆盖优先、否则跟随作业级 seatMode（thinking/reasoning/subagent）。
+    seat_modes: Object.fromEntries(
+      Object.entries(p.seatModes ?? {}).filter(([, v]) => v != null) as [string, string][],
+    ),
+    // 研讨前并行取数开关（来源链条 gatherFirst）：true = 后台研讨前先并行取数再研讨。缺省 false。
+    gather_first: p.gatherFirst ?? false,
+    // 深链接业务码：后台总结报告据此做业务链完整性核对（写实业务如 rwfx 才生效）。空 → 不注入。
+    business_code: p.businessCode ?? null,
     ...(seat
       ? {
           thinking_enabled: seat.thinking_enabled,
@@ -131,23 +151,31 @@ export function startJobKeepalive(payload: StartJobPayload): void {
   }
 }
 
-/** 查作业快照。404 → null。 */
-export async function getJob(jobId: string): Promise<RoundtableJob | null> {
-  const res = await apiFetch(`${BASE()}/${encodeURIComponent(jobId)}`, { method: "GET" });
+/** taskId 非空 → 追加 `task_id` 查询参（task 作业按 task 共享、不分权读取/控制）。 */
+function taskQuery(taskId: string | null | undefined, sep: "?" | "&"): string {
+  return taskId ? `${sep}task_id=${encodeURIComponent(taskId)}` : "";
+}
+
+/** 查作业快照。404 → null。`taskId` 非空走 task 共享读取（不分权）。 */
+export async function getJob(jobId: string, taskId?: string | null): Promise<RoundtableJob | null> {
+  const res = await apiFetch(`${BASE()}/${encodeURIComponent(jobId)}${taskQuery(taskId, "?")}`, { method: "GET" });
   if (res.status === 404) return null;
   return mapJob(await readJson<Record<string, unknown>>(res, "get job"));
 }
 
-/** 查某草稿最近一个作业。无 → null。 */
-export async function getJobByDraft(draftId: string): Promise<RoundtableJob | null> {
-  const res = await apiFetch(`${BASE()}?draft_id=${encodeURIComponent(draftId)}`, { method: "GET" });
+/** 查某草稿最近一个作业。无 → null。`taskId` 非空走 task 共享读取（不分权）。 */
+export async function getJobByDraft(draftId: string, taskId?: string | null): Promise<RoundtableJob | null> {
+  const res = await apiFetch(
+    `${BASE()}?draft_id=${encodeURIComponent(draftId)}${taskQuery(taskId, "&")}`,
+    { method: "GET" },
+  );
   const data = await readJson<Record<string, unknown> | null>(res, "get job by draft");
   return data ? mapJob(data) : null;
 }
 
-/** 回答澄清后续跑。 */
-export async function resumeJob(jobId: string, answer: string): Promise<RoundtableJob> {
-  const res = await apiFetch(`${BASE()}/${encodeURIComponent(jobId)}/resume`, {
+/** 回答澄清后续跑。`taskId` 非空 → task 共享续跑（不分权）。 */
+export async function resumeJob(jobId: string, answer: string, taskId?: string | null): Promise<RoundtableJob> {
+  const res = await apiFetch(`${BASE()}/${encodeURIComponent(jobId)}/resume${taskQuery(taskId, "?")}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ answer }),
@@ -155,9 +183,9 @@ export async function resumeJob(jobId: string, answer: string): Promise<Roundtab
   return mapJob(await readJson<Record<string, unknown>>(res, "resume job"));
 }
 
-/** 取消作业。 */
-export async function cancelJob(jobId: string): Promise<RoundtableJob> {
-  const res = await apiFetch(`${BASE()}/${encodeURIComponent(jobId)}/cancel`, { method: "POST" });
+/** 取消作业。`taskId` 非空 → task 共享取消（不分权）。 */
+export async function cancelJob(jobId: string, taskId?: string | null): Promise<RoundtableJob> {
+  const res = await apiFetch(`${BASE()}/${encodeURIComponent(jobId)}/cancel${taskQuery(taskId, "?")}`, { method: "POST" });
   return mapJob(await readJson<Record<string, unknown>>(res, "cancel job"));
 }
 
@@ -177,12 +205,12 @@ export interface StreamJobHandlers {
  *
  * 终态帧后后端会主动关闭流；本函数也在收到终态快照时调 onDone，调用方可据此 unsubscribe。
  */
-export function streamJob(jobId: string, handlers: StreamJobHandlers): () => void {
+export function streamJob(jobId: string, handlers: StreamJobHandlers, taskId?: string | null): () => void {
   const controller = new AbortController();
 
   void (async () => {
     try {
-      const res = await apiFetch(`${BASE()}/${encodeURIComponent(jobId)}/stream`, {
+      const res = await apiFetch(`${BASE()}/${encodeURIComponent(jobId)}/stream${taskQuery(taskId, "?")}`, {
         method: "GET",
         signal: controller.signal,
       });
@@ -211,7 +239,13 @@ export function streamJob(jobId: string, handlers: StreamJobHandlers): () => voi
             continue;
           }
           if (frame.event === "error") {
-            handlers.onError?.(String(frame.detail ?? "unknown stream error"));
+            const detail = String(frame.detail ?? "unknown stream error");
+            reportRoundtableError({
+              stage: "job", event: "job_stream_error_frame",
+              message: `后台作业进度流报错：${detail.slice(0, 500)}`,
+              jobId, detail: { taskId },
+            });
+            handlers.onError?.(detail);
             continue;
           }
           const job = mapJob(frame);

frontend-web/src/roundtable-planning/api/task-drafts.ts

@@ -0,0 +1,83 @@
+/**
+ * **Task-scoped** roundtable draft storage (taskId 深链聊天记录).
+ *
+ * Separate from the per-user `drafts.ts` client: records here are keyed **only by
+ * `taskId`** and are **not partitioned by user** (the deep-link audience shares
+ * them). Hits `/api/roundtable-task-drafts` (table `roundtable_task_drafts`),
+ * physically distinct from the personal `roundtable_drafts` store so the two
+ * never mix.
+ *
+ * The wire shape matches the personal store, so we reuse its types + mappers.
+ */
+
+import { apiFetch } from "@/core/api/fetch-client";
+import { getBackendBaseURL } from "@/core/config";
+
+import {
+  fromCreate,
+  fromUpdate,
+  readJson,
+  toMeta,
+  toRecord,
+  type DraftCreatePayload,
+  type DraftMeta,
+  type DraftRecord,
+  type DraftUpdatePayload,
+  type ServerDraftFull,
+  type ServerDraftMeta,
+} from "@/roundtable-planning/api/drafts";
+
+const BASE = () => `${getBackendBaseURL()}/api/roundtable-task-drafts`;
+
+/** 按外部任务 id 列出该任务全部聊天记录（轻量 meta，newest first；不分权）。 */
+export async function listTaskDraftsByTask(taskId: string): Promise<DraftMeta[]> {
+  const res = await apiFetch(`${BASE()}/by-task/${encodeURIComponent(taskId)}`, { method: "GET" });
+  const data = await readJson<{ drafts: ServerDraftMeta[] }>(res, "list task drafts");
+  return (data.drafts ?? []).map(toMeta);
+}
+
+/** 按外部任务 id 取最新一条聊天记录（不分权）。无则 null（404）。 */
+export async function getLatestTaskDraftByTask(taskId: string): Promise<DraftRecord | null> {
+  const res = await apiFetch(`${BASE()}/by-task/${encodeURIComponent(taskId)}/latest`, { method: "GET" });
+  if (res.status === 404) return null;
+  const data = await readJson<ServerDraftFull>(res, "get latest task draft");
+  return toRecord(data);
+}
+
+/** Full task draft by id (不分权). Returns null on 404. */
+export async function getTaskDraft(id: string): Promise<DraftRecord | null> {
+  const res = await apiFetch(`${BASE()}/${encodeURIComponent(id)}`, { method: "GET" });
+  if (res.status === 404) return null;
+  const data = await readJson<ServerDraftFull>(res, "get task draft");
+  return toRecord(data);
+}
+
+/** Create a task draft. `payload.taskId` is required. */
+export async function createTaskDraft(payload: DraftCreatePayload): Promise<DraftRecord> {
+  const res = await apiFetch(BASE(), {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(fromCreate(payload)),
+  });
+  const data = await readJson<ServerDraftFull>(res, "create task draft");
+  return toRecord(data);
+}
+
+export async function updateTaskDraft(id: string, patch: DraftUpdatePayload): Promise<DraftRecord | null> {
+  const res = await apiFetch(`${BASE()}/${encodeURIComponent(id)}`, {
+    method: "PUT",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(fromUpdate(patch)),
+  });
+  if (res.status === 404) return null;
+  const data = await readJson<ServerDraftFull>(res, "update task draft");
+  return toRecord(data);
+}
+
+export async function deleteTaskDraft(id: string): Promise<void> {
+  const res = await apiFetch(`${BASE()}/${encodeURIComponent(id)}`, { method: "DELETE" });
+  if (!res.ok && res.status !== 404) {
+    const text = await res.text().catch(() => "");
+    throw new Error(`delete task draft failed (${res.status}): ${text}`);
+  }
+}

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

@@ -1,4 +1,5 @@
 import React, { useCallback, useEffect, useMemo, useState } from "react";
+import { createPortal } from "react-dom";
 import type { ReactNode } from "react";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
@@ -214,7 +215,9 @@ export const ArtifactPreviewModal: React.FC<ArtifactPreviewModalProps> = ({
     [content],
   );
 
-  return (
+  // 经 portal 挂到 body：脱离会商页 <main>(`relative z-0`) 的层叠上下文，
+  // 否则 fixed 弹窗会被会商页头(z-40)/全局顶栏(z-45)盖住顶部。
+  return createPortal(
     <div
       className="fixed inset-0 z-[100] flex items-center justify-center bg-slate-900/40 backdrop-blur-sm p-6"
       onMouseDown={(e) => {
@@ -287,6 +290,7 @@ export const ArtifactPreviewModal: React.FC<ArtifactPreviewModalProps> = ({
           )}
         </div>
       </div>
-    </div>
+    </div>,
+    document.body,
   );
 };

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

@@ -31,6 +31,7 @@ import {
 import { cn } from "@/lib/utils";
 import { useDesensitizeSubtree } from "@/roundtable-planning/lib/use-desensitize-subtree";
 
+import { getStoredAuth } from "@/core/auth";
 import { listAgents } from "@/core/agents";
 
 import { listChains, setChainPublic, type ChainScope } from "../api/chains";
@@ -71,7 +72,9 @@ export function BusinessChainListBody({
   const [chains, setChains] = useState<BusinessChain[]>([]);
   const [loading, setLoading] = useState(true);
   const [error, setError] = useState<string | null>(null);
-  // 筛选：我的 / 公共（已发布）。
+  // 管理员：额外多一个「全部」筛选，且可编辑 / 发布任意账号的链条。
+  const isAdmin = getStoredAuth()?.system_role === "admin";
+  // 筛选：我的 / 公共（已发布）/（管理员）全部。
   const [scope, setScope] = useState<ChainScope>("mine");
   const [publishingId, setPublishingId] = useState<string | null>(null);
   // 实时名称表（id 小写 → 最新 name）：用于把席位的落库快照名刷新成最新（agent 改名同步）。
@@ -147,9 +150,9 @@ export function BusinessChainListBody({
 
   return (
     <>
-      {/* 筛选：我的 / 公共 */}
+      {/* 筛选：我的 / 公共 /（管理员）全部 */}
       <div className="shrink-0 flex items-center gap-1 rounded-lg border border-border bg-muted/40 p-0.5 self-start">
-        {(["mine", "public"] as const).map((s) => (
+        {((isAdmin ? ["mine", "public", "all"] : ["mine", "public"]) as ChainScope[]).map((s) => (
           <button
             key={s}
             type="button"
@@ -161,7 +164,7 @@ export function BusinessChainListBody({
                 : "text-muted-foreground hover:text-foreground",
             )}
           >
-            {s === "mine" ? "我的" : "公共"}
+            {s === "mine" ? "我的" : s === "public" ? "公共" : "全部"}
           </button>
         ))}
       </div>
@@ -195,6 +198,7 @@ export function BusinessChainListBody({
               <ChainRow
                 key={chain.id}
                 chain={chain}
+                canManage={isAdmin || chain.isMine !== false}
                 nameById={nameById}
                 publishing={publishingId === chain.id}
                 onSettings={() => onConfigure(chain.id)}
@@ -245,18 +249,20 @@ export function BusinessChainListDialog({
 
 function ChainRow({
   chain,
+  canManage,
   nameById,
   publishing,
   onSettings,
   onTogglePublic,
 }: {
   chain: BusinessChain;
+  /** 能否编辑 / 发布（本人链条 或 管理员）。 */
+  canManage: boolean;
   nameById: Map<string, string>;
   publishing: boolean;
   onSettings: () => void;
   onTogglePublic: () => void;
 }) {
-  const isMine = chain.isMine !== false;
   // 配置者用户名：后端返回 email，展示时取 @ 前的本地部分更像「用户名」。
   const ownerName = chain.ownerName ? chain.ownerName.split("@")[0] : "";
   return (
@@ -274,8 +280,8 @@ function ChainRow({
           </span>
         )}
         <div className="ml-auto flex shrink-0 items-center gap-1.5">
-          {/* 发布 / 取消发布：仅本人的链条可操作。 */}
-          {isMine && (
+          {/* 发布 / 取消发布：本人的链条或管理员可操作。 */}
+          {canManage && (
             <Button
               variant={chain.isPublic ? "secondary" : "outline"}
               size="sm"
@@ -291,8 +297,8 @@ function ChainRow({
               {chain.isPublic ? "取消发布" : "发布"}
             </Button>
           )}
-          {/* 设置（编辑）：仅本人的链条；公共里别人的链条只读浏览。 */}
-          {isMine && (
+          {/* 设置（编辑）：本人的链条或管理员；普通用户看别人的链条只读浏览。 */}
+          {canManage && (
             <Button
               variant="ghost"
               size="sm"

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

@@ -147,19 +147,28 @@ export function BusinessChainPicker({
     const chainMeta = { id: selectedChain.id, title: selectedChain.title };
     const seatNameById = new Map(selectedChain.seats.map((s) => [s.agent_id, s.name]));
     const nameOf = (id: string) => nameById.get(id) ?? seatNameById.get(id) ?? id;
+    // 席位模型覆盖（链条配置）：按 agent_id 取，空/缺省 = 跟随全局模型。
+    const modelById = new Map(selectedChain.seats.map((s) => [s.agent_id, s.model ?? null]));
+    const modelOf = (id: string) => modelById.get(id) ?? null;
+    // 席位「会商技能识别强化」开关（链条配置）：按 agent_id 取，缺省 = 关。
+    const skillById = new Map(selectedChain.seats.map((s) => [s.agent_id, s.seat_skill_directive ?? false]));
+    const skillOf = (id: string) => skillById.get(id) ?? false;
+    // 席位「推理深度覆盖」（链条配置 seat_mode）：按 agent_id 取，null/缺省 = 跟随链条级 seatMode。
+    const seatModeById = new Map(selectedChain.seats.map((s) => [s.agent_id, s.seat_mode ?? null]));
+    const seatModeOf = (id: string) => seatModeById.get(id) ?? null;
 
     // 链条带分层、过滤存活后仍并行 → dag 编排（携带快速/沙箱子模式）；否则退回线性 chain。
     if (dagPlan) {
       // dag：席位顺序按 stage 展平（与 plan 一致）。
       const agents = dagPlan.stages
         .flatMap((st) => st.agentIds)
-        .map((id) => ({ agent_id: id, name: nameOf(id) }));
-      onConfirm({ agents, mode: "dag", chain: chainMeta, plan: dagPlan, dagExecMode });
+        .map((id) => ({ agent_id: id, name: nameOf(id), model: modelOf(id), seat_skill_directive: skillOf(id), seatMode: seatModeOf(id) }));
+      onConfirm({ agents, mode: "dag", chain: chainMeta, plan: dagPlan, dagExecMode, gatherFirst: selectedChain.gatherFirst ?? false });
       return;
     }
 
-    const agents = survivingSeats.map((s) => ({ agent_id: s.agent_id, name: nameOf(s.agent_id) }));
-    onConfirm({ agents, mode: "chain", chain: chainMeta });
+    const agents = survivingSeats.map((s) => ({ agent_id: s.agent_id, name: nameOf(s.agent_id), model: modelOf(s.agent_id), seat_skill_directive: skillOf(s.agent_id), seatMode: seatModeOf(s.agent_id) }));
+    onConfirm({ agents, mode: "chain", chain: chainMeta, gatherFirst: selectedChain.gatherFirst ?? false });
   };
 
   // 整片脱敏：链条卡片区（链条名/描述/席位智能体名）。输入框不受影响（Hook 跳过）。

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

@@ -0,0 +1,250 @@
+/**
+ * 大屏绘制智能体「交互区」聊天面板（沙箱左 60%；右 40% 是抽取过程代码预览）。
+ *
+ * 从 `Step3DashboardMode` 抽出共享：圆桌 Step3「结果绘制·大屏」与独立大屏页
+ * （`DashboardAgentPage`）都复用同一套聊天 UI（流式气泡 + 模型选择 + 暂停/重画 +
+ * 修改输入框）。消息里不展示 report-json 本体（已在右侧沙箱实时渲染），用
+ * `stripReportFence` 替换成一句提示。
+ */
+import { useMemo, useRef, useState, type FormEvent } from "react";
+import {
+  CheckCircle,
+  Loader2,
+  Pause,
+  RefreshCw,
+  SendHorizontal,
+} from "lucide-react";
+
+import { useLocalSettings } from "@/core/settings";
+import { AutoGrowTextarea } from "@/components/ui/auto-grow-textarea";
+import type { ModelOption } from "@/roundtable-planning/components/Step3ReportMode";
+import { ScrollToBottomButton } from "@/roundtable-planning/components/ScrollToBottomButton";
+import { Step2Message } from "@/roundtable-planning/components/Step2Panel";
+import { useAutoScroll } from "@/roundtable-planning/hooks/useAutoScroll";
+import { useDialogueSpeedMetrics } from "@/roundtable-planning/hooks/useDialogueSpeedMetrics";
+import type { UseStep3DashboardReturn } from "@/roundtable-planning/hooks/useStep3Dashboard";
+import { stripReportFence } from "@/roundtable-planning/lib/report-template";
+
+export interface DashboardChatPanelProps {
+  phase: UseStep3DashboardReturn["phase"];
+  dialogues: UseStep3DashboardReturn["dialogues"];
+  busy: boolean;
+  error: string | null;
+  onAsk: (message: string) => void;
+  onRedraw: () => void;
+  onPause: () => void;
+  onOpenPreview: () => void;
+  hasResult: boolean;
+  selectedModel: string;
+  availableModels: ReadonlyArray<ModelOption>;
+  modelsLoading: boolean;
+  setSelectedModel: (model: string) => void;
+  /** 面板副标题（默认对齐圆桌 Step3；独立大屏页可自定义说明）。 */
+  subtitle?: string;
+  /** 完成提示语（默认「已切换到大屏页面」；独立页不自动跳，可改文案）。 */
+  doneHint?: string;
+}
+
+export function DashboardChatPanel({
+  phase,
+  dialogues,
+  busy,
+  error,
+  onAsk,
+  onRedraw,
+  onPause,
+  onOpenPreview,
+  hasResult,
+  selectedModel,
+  availableModels,
+  modelsLoading,
+  setSelectedModel,
+  subtitle = "提炼研讨成果为大屏结构化数据（右侧实时显示抽取过程）",
+  doneHint = "数据已就绪，已切换到大屏页面。",
+}: DashboardChatPanelProps) {
+  const inputLocked = phase === "creating";
+  const scrollRef = useRef<HTMLDivElement>(null);
+  const { atBottom, scrollToBottom } = useAutoScroll(scrollRef, [dialogues]);
+  const [localSettings] = useLocalSettings();
+  const speedMeterEnabled = localSettings.display.streamSpeedMeterEnabled;
+  const dialogueMetrics = useDialogueSpeedMetrics(dialogues);
+  const [text, setText] = useState("");
+
+  // 消息列表里不展示 report-json 结构化数据本体（它已在右侧沙箱实时渲染），
+  // 把数据块替换成一句「看右侧沙箱」的提示，避免左右两边重复刷整段 JSON。
+  const displayDialogues = useMemo(
+    () =>
+      dialogues.map((d) => {
+        const content = d.content ?? "";
+        if (!content) return d;
+        const stripped = stripReportFence(content, d.streaming === true);
+        return stripped === content ? d : { ...d, content: stripped };
+      }),
+    [dialogues],
+  );
+
+  const handleSubmit = (e: FormEvent<HTMLFormElement>) => {
+    e.preventDefault();
+    const t = text.trim();
+    if (!t || inputLocked) return;
+    setText("");
+    onAsk(t);
+  };
+
+  return (
+    <div className="flex h-full min-h-0 flex-col bg-slate-50/20">
+      {/* 面板头：智能体名 + 模型选择 + 暂停/重画 */}
+      <div className="shrink-0 flex items-center justify-between gap-2 border-b border-slate-100 bg-white px-4 py-2.5">
+        <div className="flex items-center gap-2 min-w-0">
+          <div className="w-6 h-6 shrink-0 rounded-lg bg-gradient-to-tr from-primary to-[var(--brand-200)] flex items-center justify-center text-white text-xs shadow-sm">
+            📊
+          </div>
+          <div className="leading-tight min-w-0">
+            <div className="text-xs font-bold text-slate-800 truncate">大屏绘制智能体</div>
+            <div className="text-[10px] text-slate-400 truncate">{subtitle}</div>
+          </div>
+        </div>
+        <div className="flex items-center gap-2 shrink-0">
+          <select
+            id="step3-dashboard-model-select"
+            value={selectedModel}
+            onChange={(e) => setSelectedModel(e.target.value)}
+            disabled={busy || modelsLoading || availableModels.length === 0}
+            title={
+              modelsLoading
+                ? "正在加载模型列表…"
+                : availableModels.length === 0
+                  ? "未在 config.yaml 中配置任何模型"
+                  : busy
+                    ? "绘制中不可切换；完成后或重新绘制时生效"
+                    : "切换绘制使用的推理模型（下次绘制生效）"
+            }
+            className="max-w-[160px] bg-slate-50/50 border border-slate-200 rounded-xl px-2.5 py-1.5 text-[11px] font-bold text-slate-700 cursor-pointer focus:outline-none focus:border-primary focus:ring-1 focus:ring-[var(--brand-200)]/50 disabled:opacity-50 disabled:cursor-not-allowed dark:bg-secondary dark:text-foreground dark:border-border"
+          >
+            {availableModels.length === 0 && (
+              <option value="">{modelsLoading ? "加载中…" : "未配置模型"}</option>
+            )}
+            {availableModels.map((m) => (
+              <option key={m.name} value={m.name}>
+                {m.display_name && m.display_name !== m.name ? `${m.display_name} (${m.name})` : m.name}
+              </option>
+            ))}
+          </select>
+          {busy ? (
+            <button
+              type="button"
+              onClick={onPause}
+              title="中止当前绘制"
+              className="bg-white border border-amber-200 text-amber-700 hover:bg-amber-50 text-[10.5px] font-bold px-2.5 py-1.5 rounded-xl flex items-center gap-1 transition"
+            >
+              <Pause className="w-3.5 h-3.5" />
+              中止
+            </button>
+          ) : (
+            <button
+              type="button"
+              onClick={onRedraw}
+              title="丢弃上下文，从头重新绘制"
+              className="bg-white border border-slate-200 text-slate-700 hover:bg-slate-50 text-[10.5px] font-bold px-2.5 py-1.5 rounded-xl flex items-center gap-1 transition"
+            >
+              <RefreshCw className="w-3.5 h-3.5 text-slate-500" />
+              重新绘制
+            </button>
+          )}
+        </div>
+      </div>
+
+      {/* 聊天记录 */}
+      <div className="relative flex-1 min-h-0 flex flex-col">
+        <div ref={scrollRef} className="flex-1 min-h-0 overflow-y-auto overflow-x-hidden p-4 space-y-4 bg-white">
+          {phase === "creating" && dialogues.length === 0 && (
+            <div className="flex items-center gap-2 text-xs text-slate-500">
+              <Loader2 className="w-3.5 h-3.5 animate-spin text-primary" />
+              正在初始化绘制线程…
+            </div>
+          )}
+
+          {displayDialogues.map((msg) => (
+            <Step2Message
+              key={msg.id}
+              msg={msg}
+              metric={speedMeterEnabled ? dialogueMetrics.get(msg.id) : undefined}
+            />
+          ))}
+
+          {busy && (
+            <div className="inline-flex items-center gap-2 rounded-full border bg-white px-2.5 py-1 text-[11px] text-slate-500">
+              <span className="bg-primary size-1.5 animate-pulse rounded-full" />
+              右侧沙箱实时显示数据抽取过程
+            </div>
+          )}
+
+          {phase === "error" && (
+            <div className="rounded-xl border border-rose-200 bg-rose-50 p-3 text-xs text-rose-700">
+              <div className="font-bold mb-1">绘制失败</div>
+              <div className="leading-relaxed break-all">{error}</div>
+              <button
+                type="button"
+                onClick={onRedraw}
+                className="mt-2 inline-flex items-center gap-1 text-[11px] font-bold text-rose-700 underline hover:text-rose-800"
+              >
+                <RefreshCw className="w-3 h-3" />
+                重试
+              </button>
+            </div>
+          )}
+
+          {phase === "done" && (
+            <div className="flex items-center gap-2 text-xs font-bold text-emerald-600">
+              <CheckCircle className="w-4 h-4" />
+              {doneHint}
+              {hasResult && (
+                <button
+                  type="button"
+                  onClick={onOpenPreview}
+                  className="ml-1 inline-flex items-center gap-1 text-[11px] font-bold text-primary underline hover:opacity-80"
+                >
+                  在沙箱打开 HTML 预览
+                </button>
+              )}
+            </div>
+          )}
+        </div>
+        {!atBottom && <ScrollToBottomButton onClick={scrollToBottom} />}
+
+        {/* 问答修改输入框 */}
+        <form onSubmit={handleSubmit} className="shrink-0 border-t border-slate-100 bg-white px-3 py-3">
+          <div className="flex items-end gap-2 rounded-2xl border border-slate-200 bg-slate-50/70 px-3 py-2 focus-within:border-primary/60 focus-within:bg-white focus-within:ring-2 focus-within:ring-[var(--brand-200)]/40">
+            <AutoGrowTextarea
+              maxHeight={224}
+              value={text}
+              onChange={(e) => setText(e.target.value)}
+              onKeyDown={(e) => {
+                if (e.key === "Enter" && !e.shiftKey) {
+                  e.preventDefault();
+                  e.currentTarget.form?.requestSubmit();
+                }
+              }}
+              disabled={inputLocked}
+              rows={1}
+              placeholder={
+                busy
+                  ? "随时输入修改要求——发送会打断当前绘制并按新要求重出数据"
+                  : "输入修改要求，例如：把风险分布换成柱状图，新增一个执行路线席位"
+              }
+              className="min-h-8 max-h-56 flex-1 resize-none bg-transparent py-1.5 text-xs leading-relaxed text-slate-800 placeholder:text-slate-400 focus:outline-none disabled:cursor-not-allowed disabled:opacity-60"
+            />
+            <button
+              type="submit"
+              disabled={inputLocked || text.trim().length === 0}
+              title={inputLocked ? "正在初始化线程，请稍候" : "发送修改要求"}
+              className="mb-0.5 flex h-8 w-8 shrink-0 items-center justify-center rounded-xl bg-primary text-white transition hover:bg-[var(--brand-900)] disabled:cursor-not-allowed disabled:opacity-50"
+            >
+              {inputLocked ? <Loader2 className="h-4 w-4 animate-spin" /> : <SendHorizontal className="h-4 w-4" />}
+            </button>
+          </div>
+        </form>
+      </div>
+    </div>
+  );
+}

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

@@ -18,6 +18,11 @@ export interface DispatchChainJobModalProps {
   onOpenChange: (open: boolean) => void;
   title?: string;
   onView?: (job: RoundtableJob) => void;
+  /**
+   * 外部任务 id（taskId 深链会商）。非空 → 按 task 共享读取/控制作业（不分权），
+   * 任何人打开同一 task 都能看在跑的研讨流程图。普通模式留空。
+   */
+  taskId?: string | null;
 }
 
 export function DispatchChainJobModal({
@@ -26,6 +31,7 @@ export function DispatchChainJobModal({
   onOpenChange,
   title,
   onView,
+  taskId = null,
 }: DispatchChainJobModalProps) {
   const [job, setJob] = useState<RoundtableJob | null>(null);
 
@@ -36,24 +42,28 @@ export function DispatchChainJobModal({
     }
     let cancelled = false;
     // 首帧快照：弹窗一打开就有内容，不必等 SSE 第一帧。
-    void getJob(jobId)
+    void getJob(jobId, taskId)
       .then((j) => {
         if (!cancelled && j) setJob(j);
       })
       .catch(() => {});
-    const unsubscribe = streamJob(jobId, {
-      onProgress: (j) => {
-        if (!cancelled) setJob(j);
+    const unsubscribe = streamJob(
+      jobId,
+      {
+        onProgress: (j) => {
+          if (!cancelled) setJob(j);
+        },
+        onError: () => {
+          /* 流错误静默：保留已拿到的最后一帧；可后续加 toast */
+        },
       },
-      onError: () => {
-        /* 流错误静默：保留已拿到的最后一帧；可后续加 toast */
-      },
-    });
+      taskId,
+    );
     return () => {
       cancelled = true;
       unsubscribe();
     };
-  }, [open, jobId]);
+  }, [open, jobId, taskId]);
 
   return (
     <DispatchChainModal
@@ -75,7 +85,7 @@ export function DispatchChainJobModal({
         jobId
           ? (answer) => {
               // 乐观更新为 running，随后 SSE 会推真状态续上。
-              void resumeJob(jobId, answer)
+              void resumeJob(jobId, answer, taskId)
                 .then((j) => setJob(j))
                 .catch(() => {});
             }
@@ -84,7 +94,7 @@ export function DispatchChainJobModal({
       onCancel={
         jobId
           ? () => {
-              void cancelJob(jobId)
+              void cancelJob(jobId, taskId)
                 .then((j) => setJob(j))
                 .catch(() => {});
             }

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

@@ -15,12 +15,14 @@ import {
   useRef,
   useState,
 } from "react";
+import { createPortal } from "react-dom";
 import {
   applyNodeChanges,
   Background,
   BackgroundVariant,
   Handle,
   MarkerType,
+  MiniMap,
   Position,
   ReactFlow,
   ReactFlowProvider,
@@ -32,11 +34,14 @@ import {
 } from "@xyflow/react";
 import "@xyflow/react/dist/style.css";
 import {
+  Check,
   FileText,
   Loader2,
   LocateFixed,
   Maximize2,
   Minimize2,
+  Pencil,
+  Trash2,
   Workflow,
   X,
   ZoomIn,
@@ -44,14 +49,36 @@ import {
 } from "lucide-react";
 
 import { cn } from "@/lib/utils";
+import { useTheme } from "@/contexts/ThemeContext";
 import {
-  FLOW_NODE_TYPE_META,
+  applyNodeEdit,
+  deleteNodeFromGraph,
+  flowNodeMeta,
   FLOW_NODE_W,
   layoutFlowGraph,
   type FlowGraphData,
   type FlowGraphNode,
+  type FlowOrientation,
 } from "@/roundtable-planning/lib/flow-graph";
 
+/**
+ * 深蓝主题色板（《深蓝色 UI 规范》ZS-004 / ZS-002）。浅色保持原 slate/white。
+ * 用于流程图弹窗在深色下的容器 / 头部 / 画布 / 连线 / 图例 / 小地图 / 详情弹窗。
+ */
+const DARK = {
+  pageBg: "#0C1836", // ZS-004-09 画布底
+  cardBg: "#122347", // ZS-004-08 头部 / 详情卡底
+  border: "#1A2F5A", // ZS-004-07 卡片边框
+  borderStrong: "#2D4473", // ZS-004-06 弱分割
+  text: "#C5CFE0", // ZS-004-02 正文
+  textMuted: "#6E88B0", // ZS-004-04 次级文字
+  primary: "#1677FF", // ZS-002-06 主色
+  link: "#4096FF", // ZS-002-05 链接
+  dots: "#2D4473", // 画布点阵
+  edge: "#4A6491", // ZS-004-05 静态连线
+  edgeActive: "#4096FF", // 活动连线
+} as const;
+
 interface FlowGraphPanelProps {
   data: FlowGraphData;
   /** 流式绘制中（决定蚂蚁线 + 自动 fitView 跟随）。 */
@@ -59,17 +86,34 @@ interface FlowGraphPanelProps {
   onClose: () => void;
   /** 沙箱里有 md 报告时提供：工具栏显示「MD 报告」按钮，点击切回 Markdown 预览。 */
   onSwitchToReport?: () => void;
+  /** Phase 3：画布手动编辑——传入则节点详情弹窗出现「编辑 / 删除」，回写整张新图。 */
+  onChange?: (next: FlowGraphData) => void;
+  /** 布局方向：默认 "vertical"（自上而下）；弹窗里用 "horizontal" 横向铺开。 */
+  orientation?: FlowOrientation;
+  /** 右下角缩略图（小地图）—— 弹窗大画布里便于纵览定位。 */
+  miniMap?: boolean;
 }
 
 // ── 自定义节点（按 type 着色的卡片）────────────────────────────────────────
 
 function FlowCardNode({ data }: NodeProps) {
-  const node = (data as { node?: FlowGraphNode; scale?: number }).node;
-  const scale = (data as { node?: FlowGraphNode; scale?: number }).scale ?? 1;
+  const d = data as {
+    node?: FlowGraphNode;
+    scale?: number;
+    orientation?: FlowOrientation;
+    dark?: boolean;
+  };
+  const node = d.node;
+  const scale = d.scale ?? 1;
   if (!node) return null;
-  const meta = FLOW_NODE_TYPE_META[node.type];
+  const meta = flowNodeMeta(d.dark ?? false)[node.type];
   // 节点宽度随容器宽度缩放（宽时放大、窄时缩小）。
   const scaledWidth = FLOW_NODE_W * scale;
+  // 横向布局连入/连出走左右两侧，纵向走上下。
+  const horizontal = d.orientation === "horizontal";
+  const targetPos = horizontal ? Position.Left : Position.Top;
+  const sourcePos = horizontal ? Position.Right : Position.Bottom;
+  const handleColor = d.dark ? "!bg-[#4A6491]" : "!bg-slate-400";
   return (
     <div
       style={{
@@ -81,7 +125,7 @@ function FlowCardNode({ data }: NodeProps) {
       className="cursor-pointer rounded-xl border-2 px-3 py-2 shadow-sm transition hover:shadow-md"
       title="点击查看详情"
     >
-      <Handle type="target" position={Position.Top} className="!h-1.5 !w-1.5 !bg-slate-400" />
+      <Handle type="target" position={targetPos} className={cn("!h-1.5 !w-1.5", handleColor)} />
       <div className="mb-0.5 flex items-center gap-1.5">
         <span style={{ background: meta.dot }} className="size-2 shrink-0 rounded-full" />
         <span className="text-[9px] font-bold uppercase tracking-wider opacity-70" style={{ fontSize: `${9 * scale}px` }}>
@@ -89,7 +133,7 @@ function FlowCardNode({ data }: NodeProps) {
         </span>
       </div>
       <div className="break-words font-bold leading-snug" style={{ fontSize: `${11.5 * scale}px` }}>{node.label}</div>
-      <Handle type="source" position={Position.Bottom} className="!h-1.5 !w-1.5 !bg-slate-400" />
+      <Handle type="source" position={sourcePos} className={cn("!h-1.5 !w-1.5", handleColor)} />
     </div>
   );
 }
@@ -106,8 +150,13 @@ function FlowCanvasInner({
   onToggleFullscreen,
   onClose,
   onSwitchToReport,
+  onChange,
+  orientation = "vertical",
+  miniMap = false,
 }: FlowGraphPanelProps & { fullscreen: boolean; onToggleFullscreen: () => void }) {
   const rf = useReactFlow();
+  const { theme } = useTheme();
+  const isDark = theme === "dark";
   const [selectedId, setSelectedId] = useState<string | null>(null);
   const [scale, setScale] = useState(1);
   const containerRef = useRef<HTMLDivElement>(null);
@@ -136,7 +185,7 @@ function FlowCanvasInner({
     };
   }, [rf]);
 
-  const layoutNodes = useMemo(() => layoutFlowGraph(data), [data]);
+  const layoutNodes = useMemo(() => layoutFlowGraph(data, orientation), [data, orientation]);
   const derivedNodes: Node[] = useMemo(
     () =>
       layoutNodes.map((n) => ({
@@ -144,9 +193,9 @@ function FlowCanvasInner({
         type: "flowCard",
         // 节点随 scale 放大 → 布局坐标同步乘 scale，间距一起拉开，避免同层重叠。
         position: manualPosRef.current.get(n.id) ?? { x: n.x * scale, y: n.y * scale },
-        data: { node: n, scale },
+        data: { node: n, scale, orientation, dark: isDark },
       })),
-    [layoutNodes, scale],
+    [layoutNodes, scale, orientation, isDark],
   );
 
   const [nodes, setNodes] = useState<Node[]>(derivedNodes);
@@ -165,7 +214,13 @@ function FlowCanvasInner({
     () =>
       data.edges.map((e) => {
         const active = streaming && (e.to === newestNodeId || e.from === newestNodeId);
-        const color = active ? "#3b82f6" : "#94a3b8";
+        const color = active
+          ? isDark
+            ? DARK.edgeActive
+            : "#3b82f6"
+          : isDark
+            ? DARK.edge
+            : "#94a3b8";
         return {
           id: `e-${e.from}->${e.to}`,
           source: e.from,
@@ -174,11 +229,11 @@ function FlowCanvasInner({
           animated: active,
           style: { stroke: color, strokeWidth: active ? 2 : 1.5 },
           markerEnd: { type: MarkerType.ArrowClosed, color, width: 16, height: 16 },
-          labelStyle: { fontSize: 10, fill: "#64748b", fontWeight: 700 },
-          labelBgStyle: { fill: "#ffffff", fillOpacity: 0.85 },
+          labelStyle: { fontSize: 10, fill: isDark ? DARK.text : "#64748b", fontWeight: 700 },
+          labelBgStyle: { fill: isDark ? DARK.cardBg : "#ffffff", fillOpacity: isDark ? 0.9 : 0.85 },
         } satisfies Edge;
       }),
-    [data.edges, streaming, newestNodeId],
+    [data.edges, streaming, newestNodeId, isDark],
   );
 
   // 流式中节点增加 → 画布平滑 fitView 跟随生长（用户暂停流后不再打扰）。
@@ -193,15 +248,30 @@ function FlowCanvasInner({
   const selectedNode = selectedId ? data.nodes.find((n) => n.id === selectedId) ?? null : null;
 
   return (
-    <div className="flex h-full min-h-0 flex-col">
+    <div
+      className="flex h-full min-h-0 flex-col"
+      style={isDark ? { background: DARK.pageBg } : undefined}
+    >
       {/* 头部：标题 + 工具栏 */}
-      <div className="shrink-0 flex items-center justify-between gap-2 border-b border-slate-100 bg-white px-4 py-2.5">
+      <div
+        className={cn(
+          "shrink-0 flex items-center justify-between gap-2 border-b px-4 py-2.5",
+          isDark ? "" : "border-slate-100 bg-white",
+        )}
+        style={isDark ? { background: DARK.cardBg, borderColor: DARK.border } : undefined}
+      >
         <div className="flex min-w-0 items-center gap-2">
           <Workflow className="h-4 w-4 shrink-0 text-primary" />
-          <span className="truncate text-xs font-bold text-slate-800">
+          <span
+            className="truncate text-xs font-bold text-slate-800"
+            style={isDark ? { color: DARK.text } : undefined}
+          >
             {data.title || "方案流程图"}
           </span>
-          <span className="shrink-0 rounded bg-slate-100 px-1.5 py-0.5 font-mono text-[10px] text-slate-500">
+          <span
+            className="shrink-0 rounded bg-slate-100 px-1.5 py-0.5 font-mono text-[10px] text-slate-500"
+            style={isDark ? { background: "rgba(45,68,115,0.5)", color: DARK.textMuted } : undefined}
+          >
             {data.nodes.length} 节点 · {data.edges.length} 连线
           </span>
           {streaming && (
@@ -217,7 +287,8 @@ function FlowCanvasInner({
               type="button"
               title="切回 Markdown 报告预览（流程图可随时再打开）"
               onClick={onSwitchToReport}
-              className="mr-1 inline-flex h-7 items-center gap-1 rounded-lg border border-slate-200/70 bg-white px-2 text-[10.5px] font-bold text-slate-600 transition hover:border-primary/40 hover:text-primary"
+              className="mr-1 inline-flex h-7 items-center gap-1 rounded-lg border border-slate-200/70 bg-white px-2 text-[10.5px] font-bold text-slate-600 transition hover:border-primary/40 hover:text-primary dark:hover:text-primary"
+              style={isDark ? { background: "transparent", borderColor: DARK.border, color: DARK.text } : undefined}
             >
               <FileText className="h-3.5 w-3.5" />
               MD 报告
@@ -262,13 +333,50 @@ function FlowCanvasInner({
           deleteKeyCode={null}
           proOptions={{ hideAttribution: true }}
         >
-          <Background variant={BackgroundVariant.Dots} gap={18} size={1} color="#cbd5e1" />
+          <Background
+            variant={BackgroundVariant.Dots}
+            gap={18}
+            size={1}
+            color={isDark ? DARK.dots : "#cbd5e1"}
+          />
+          {miniMap && (
+            <MiniMap
+              position="bottom-right"
+              pannable
+              zoomable
+              nodeColor={(n) => {
+                const t = (n.data as { node?: FlowGraphNode }).node?.type;
+                return (t && flowNodeMeta(isDark)[t]?.dot) || (isDark ? DARK.textMuted : "#94a3b8");
+              }}
+              nodeStrokeWidth={2}
+              maskColor={isDark ? "rgba(6,14,36,0.6)" : "rgba(240,240,240,0.6)"}
+              className={cn(
+                "!bottom-2 !right-2 !m-0 overflow-hidden rounded-lg border shadow-sm backdrop-blur-sm",
+                isDark ? "" : "border-slate-200/70 bg-white/90",
+              )}
+              style={
+                isDark
+                  ? { width: 168, height: 112, background: "rgba(18,35,71,0.9)", borderColor: DARK.border }
+                  : { width: 168, height: 112 }
+              }
+            />
+          )}
         </ReactFlow>
 
         {/* 图例 */}
-        <div className="pointer-events-none absolute bottom-2 left-2 flex flex-wrap items-center gap-x-2.5 gap-y-1 rounded-lg border border-slate-200/70 bg-white/85 px-2.5 py-1.5 backdrop-blur-sm">
-          {Object.entries(FLOW_NODE_TYPE_META).map(([type, meta]) => (
-            <span key={type} className="inline-flex items-center gap-1 text-[9.5px] font-semibold text-slate-500">
+        <div
+          className={cn(
+            "pointer-events-none absolute bottom-2 left-2 flex flex-wrap items-center gap-x-2.5 gap-y-1 rounded-lg border px-2.5 py-1.5 backdrop-blur-sm",
+            isDark ? "" : "border-slate-200/70 bg-white/85",
+          )}
+          style={isDark ? { background: "rgba(18,35,71,0.85)", borderColor: DARK.border } : undefined}
+        >
+          {Object.entries(flowNodeMeta(isDark)).map(([type, meta]) => (
+            <span
+              key={type}
+              className="inline-flex items-center gap-1 text-[9.5px] font-semibold text-slate-500"
+              style={isDark ? { color: DARK.textMuted } : undefined}
+            >
               <span style={{ background: meta.dot }} className="size-1.5 rounded-full" />
               {meta.label}
             </span>
@@ -276,13 +384,15 @@ function FlowCanvasInner({
         </div>
       </div>
 
-      {/* 节点详情弹窗 */}
+      {/* 节点详情弹窗（传入 onChange 时可编辑 / 删除节点） */}
       {selectedNode && (
         <NodeDetailModal
           node={selectedNode}
           data={data}
+          dark={isDark}
           onClose={() => setSelectedId(null)}
           onJump={(id) => setSelectedId(id)}
+          onChange={onChange}
         />
       )}
     </div>
@@ -298,12 +408,15 @@ function ToolButton({
   onClick: () => void;
   children: React.ReactNode;
 }) {
+  const { theme } = useTheme();
+  const isDark = theme === "dark";
   return (
     <button
       type="button"
       title={title}
       onClick={onClick}
       className="flex h-7 w-7 items-center justify-center rounded-lg border border-slate-200/70 bg-white text-slate-500 transition hover:border-primary/40 hover:text-primary"
+      style={isDark ? { background: "transparent", borderColor: DARK.border, color: DARK.textMuted } : undefined}
     >
       {children}
     </button>
@@ -315,19 +428,42 @@ function ToolButton({
 function NodeDetailModal({
   node,
   data,
+  dark = false,
   onClose,
   onJump,
+  onChange,
 }: {
   node: FlowGraphNode;
   data: FlowGraphData;
+  dark?: boolean;
   onClose: () => void;
   onJump: (id: string) => void;
+  /** Phase 3：传入则可编辑 / 删除该节点（回写整张新图）。 */
+  onChange?: (next: FlowGraphData) => void;
 }) {
-  const meta = FLOW_NODE_TYPE_META[node.type];
+  const meta = flowNodeMeta(dark)[node.type];
   const labelOf = (id: string) => data.nodes.find((n) => n.id === id)?.label ?? id;
   const incoming = data.edges.filter((e) => e.to === node.id);
   const outgoing = data.edges.filter((e) => e.from === node.id);
 
+  const [editing, setEditing] = useState(false);
+  const [label, setLabel] = useState(node.label);
+  const [group, setGroup] = useState(node.group ?? "");
+  const [detail, setDetail] = useState(node.detail ?? "");
+
+  const handleSave = () => {
+    onChange?.(applyNodeEdit(data, node.id, { label, group, detail }));
+    setEditing(false);
+    onClose();
+  };
+  const handleDelete = () => {
+    if (typeof window !== "undefined" && !window.confirm(`删除节点「${node.label}」及其连线？此操作不可撤销。`)) {
+      return;
+    }
+    onChange?.(deleteNodeFromGraph(data, node.id));
+    onClose();
+  };
+
   return (
     <div
       className="absolute inset-0 z-30 flex items-center justify-center bg-black/30 p-4 backdrop-blur-[1px]"
@@ -335,6 +471,7 @@ function NodeDetailModal({
     >
       <div
         className="w-full max-w-md overflow-hidden rounded-2xl border border-slate-200 bg-white shadow-xl"
+        style={dark ? { background: DARK.cardBg, borderColor: DARK.border } : undefined}
         onClick={(e) => e.stopPropagation()}
       >
         <div
@@ -345,7 +482,7 @@ function NodeDetailModal({
             <span style={{ background: meta.dot }} className="size-2.5 shrink-0 rounded-full" />
             <span
               className="shrink-0 rounded px-1.5 py-0.5 text-[10px] font-bold"
-              style={{ background: "#ffffffaa", color: meta.text }}
+              style={{ background: dark ? "rgba(6,14,36,0.45)" : "#ffffffaa", color: meta.text }}
             >
               {node.group?.trim() || meta.label}
             </span>
@@ -357,43 +494,157 @@ function NodeDetailModal({
             type="button"
             onClick={onClose}
             className="shrink-0 rounded-md p-1 text-slate-500 hover:bg-white/60 hover:text-slate-700"
+            style={dark ? { color: DARK.textMuted } : undefined}
           >
             <X className="h-4 w-4" />
           </button>
         </div>
-        <div className="max-h-[50vh] space-y-3 overflow-y-auto p-4">
-          <div>
-            <div className="mb-1 text-[10px] font-bold uppercase tracking-widest text-slate-400">
-              详细说明
-            </div>
-            <p className="text-xs leading-relaxed text-slate-700">
-              {node.detail?.trim() || "（该节点未提供详细说明）"}
-            </p>
+
+        {editing ? (
+          <div className="max-h-[55vh] space-y-3 overflow-y-auto p-4">
+            <EditField label="节点名称（label）" value={label} onChange={setLabel} dark={dark} />
+            <EditField label="所属层级（group，如 目的 / 行为体）" value={group} onChange={setGroup} dark={dark} />
+            <EditField label="详细内容（detail，名称+理由）" value={detail} onChange={setDetail} multiline dark={dark} />
           </div>
-          {incoming.length > 0 && (
-            <ConnectionList title="上游（来自）" entries={incoming.map((e) => ({ id: e.from, label: labelOf(e.from), edgeLabel: e.label }))} onJump={onJump} />
-          )}
-          {outgoing.length > 0 && (
-            <ConnectionList title="下游（去往）" entries={outgoing.map((e) => ({ id: e.to, label: labelOf(e.to), edgeLabel: e.label }))} onJump={onJump} />
-          )}
-        </div>
+        ) : (
+          <div className="max-h-[50vh] space-y-3 overflow-y-auto p-4">
+            <div>
+              <div
+                className="mb-1 text-[10px] font-bold uppercase tracking-widest text-slate-400"
+                style={dark ? { color: DARK.textMuted } : undefined}
+              >
+                详细说明
+              </div>
+              <p
+                className="text-xs leading-relaxed text-slate-700 whitespace-pre-wrap"
+                style={dark ? { color: DARK.text } : undefined}
+              >
+                {node.detail?.trim() || "（该节点未提供详细说明）"}
+              </p>
+            </div>
+            {incoming.length > 0 && (
+              <ConnectionList title="上游（来自）" entries={incoming.map((e) => ({ id: e.from, label: labelOf(e.from), edgeLabel: e.label }))} onJump={onJump} dark={dark} />
+            )}
+            {outgoing.length > 0 && (
+              <ConnectionList title="下游（去往）" entries={outgoing.map((e) => ({ id: e.to, label: labelOf(e.to), edgeLabel: e.label }))} onJump={onJump} dark={dark} />
+            )}
+          </div>
+        )}
+
+        {/* 编辑 / 删除 操作栏（仅传入 onChange 时显示） */}
+        {onChange && (
+          <div
+            className="flex items-center justify-between gap-2 border-t border-slate-100 bg-slate-50/60 px-4 py-2.5"
+            style={dark ? { borderColor: DARK.border, background: "rgba(12,24,54,0.6)" } : undefined}
+          >
+            {editing ? (
+              <>
+                <button
+                  type="button"
+                  onClick={() => setEditing(false)}
+                  className="rounded-lg px-2.5 py-1.5 text-[11px] font-bold text-slate-500 hover:bg-slate-200/60"
+                  style={dark ? { color: DARK.textMuted } : undefined}
+                >
+                  取消
+                </button>
+                <button
+                  type="button"
+                  onClick={handleSave}
+                  className="inline-flex items-center gap-1 rounded-lg bg-primary px-3 py-1.5 text-[11px] font-bold text-white hover:bg-[var(--brand-900)]"
+                >
+                  <Check className="h-3.5 w-3.5" />
+                  保存
+                </button>
+              </>
+            ) : (
+              <>
+                <button
+                  type="button"
+                  onClick={handleDelete}
+                  className="inline-flex items-center gap-1 rounded-lg border border-rose-200 px-2.5 py-1.5 text-[11px] font-bold text-rose-600 hover:bg-rose-50"
+                >
+                  <Trash2 className="h-3.5 w-3.5" />
+                  删除节点
+                </button>
+                <button
+                  type="button"
+                  onClick={() => setEditing(true)}
+                  className="inline-flex items-center gap-1 rounded-lg border border-slate-200 px-3 py-1.5 text-[11px] font-bold text-slate-700 hover:border-primary/40 hover:text-primary"
+                  style={dark ? { borderColor: DARK.border, color: DARK.text } : undefined}
+                >
+                  <Pencil className="h-3.5 w-3.5" />
+                  编辑
+                </button>
+              </>
+            )}
+          </div>
+        )}
       </div>
     </div>
   );
 }
 
+function EditField({
+  label,
+  value,
+  onChange,
+  multiline,
+  dark = false,
+}: {
+  label: string;
+  value: string;
+  onChange: (v: string) => void;
+  multiline?: boolean;
+  dark?: boolean;
+}) {
+  const fieldStyle = dark
+    ? { background: "rgba(6,14,36,0.45)", borderColor: DARK.border, color: DARK.text }
+    : undefined;
+  return (
+    <div>
+      <div
+        className="mb-1 text-[10px] font-bold uppercase tracking-widest text-slate-400"
+        style={dark ? { color: DARK.textMuted } : undefined}
+      >
+        {label}
+      </div>
+      {multiline ? (
+        <textarea
+          value={value}
+          onChange={(e) => onChange(e.target.value)}
+          rows={4}
+          className="w-full resize-none rounded-lg border border-slate-200 bg-white px-2.5 py-1.5 text-xs leading-relaxed text-slate-800 focus:border-primary focus:outline-none focus:ring-1 focus:ring-[var(--brand-200)]/50"
+          style={fieldStyle}
+        />
+      ) : (
+        <input
+          value={value}
+          onChange={(e) => onChange(e.target.value)}
+          className="w-full rounded-lg border border-slate-200 bg-white px-2.5 py-1.5 text-xs text-slate-800 focus:border-primary focus:outline-none focus:ring-1 focus:ring-[var(--brand-200)]/50"
+          style={fieldStyle}
+        />
+      )}
+    </div>
+  );
+}
+
 function ConnectionList({
   title,
   entries,
   onJump,
+  dark = false,
 }: {
   title: string;
   entries: Array<{ id: string; label: string; edgeLabel?: string }>;
   onJump: (id: string) => void;
+  dark?: boolean;
 }) {
   return (
     <div>
-      <div className="mb-1 text-[10px] font-bold uppercase tracking-widest text-slate-400">
+      <div
+        className="mb-1 text-[10px] font-bold uppercase tracking-widest text-slate-400"
+        style={dark ? { color: DARK.textMuted } : undefined}
+      >
         {title}
       </div>
       <div className="flex flex-wrap gap-1.5">
@@ -403,11 +654,15 @@ function ConnectionList({
             type="button"
             onClick={() => onJump(entry.id)}
             className="inline-flex items-center gap-1 rounded-lg border border-slate-200 bg-slate-50 px-2 py-1 text-[11px] font-semibold text-slate-700 transition hover:border-primary/40 hover:text-primary"
+            style={dark ? { borderColor: DARK.border, background: "rgba(6,14,36,0.4)", color: DARK.text } : undefined}
             title="查看该节点详情"
           >
             {entry.label}
             {entry.edgeLabel && (
-              <span className="rounded bg-slate-200/80 px-1 text-[9px] text-slate-500">
+              <span
+                className="rounded bg-slate-200/80 px-1 text-[9px] text-slate-500"
+                style={dark ? { background: "rgba(45,68,115,0.6)", color: DARK.textMuted } : undefined}
+              >
                 {entry.edgeLabel}
               </span>
             )}
@@ -420,15 +675,19 @@ function ConnectionList({
 
 // ── 外壳：覆盖右栏 / 全屏切换 ───────────────────────────────────────────────
 
-export function FlowGraphPanel({ data, streaming, onClose, onSwitchToReport }: FlowGraphPanelProps) {
+export function FlowGraphPanel({ data, streaming, onClose, onSwitchToReport, onChange, orientation, miniMap }: FlowGraphPanelProps) {
   const [fullscreen, setFullscreen] = useState(false);
-  return (
+  const { theme } = useTheme();
+  const isDark = theme === "dark";
+  const inner = (
     <div
       className={cn(
         "flex flex-col bg-white",
-        // 非全屏=填满所在面板（Step3 放在右侧沙箱位，不覆盖左侧消息列表）；全屏才整页覆盖。
-        fullscreen ? "fixed inset-0 z-[80]" : "relative h-full min-h-0 w-full",
+        // 非全屏=填满所在面板（Step3 放在右侧沙箱位，不覆盖左侧消息列表）；
+        // 全屏=覆盖整个视口（z 高于 app 顶部导航，保证顶部工具栏可见、可点「退出全屏」）。
+        fullscreen ? "fixed inset-0 z-[9999]" : "relative h-full min-h-0 w-full",
       )}
+      style={isDark ? { background: DARK.pageBg } : undefined}
     >
       <ReactFlowProvider>
         <FlowCanvasInner
@@ -438,8 +697,17 @@ export function FlowGraphPanel({ data, streaming, onClose, onSwitchToReport }: F
           onToggleFullscreen={() => setFullscreen((f) => !f)}
           onClose={onClose}
           onSwitchToReport={onSwitchToReport}
+          onChange={onChange}
+          orientation={orientation}
+          miniMap={miniMap}
         />
       </ReactFlowProvider>
     </div>
   );
+  // 全屏时 portal 到 body：脱离任何带 transform/overflow 的祖先（Step2 沙箱分栏等），
+  // 否则 `fixed` 会被祖先裁剪、顶部工具栏被 app 导航栏盖住（即本次 bug）。
+  if (fullscreen && typeof document !== "undefined") {
+    return createPortal(inner, document.body);
+  }
+  return inner;
 }

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

@@ -67,6 +67,11 @@ import type { IntentSummary } from "@/roundtable-planning/api/intent";
 
 export interface Step1PanelProps {
   // ─── State ────────────────────────────────────────────────────
+  /**
+   * 头部左侧自定义内容（深链 taskId 模式：用「策划流程」小图取代默认标题）。
+   * 不传 → 显示默认「任务意图理解 (人机问答)」标题。右侧「问答轮次」始终保留。
+   */
+  headerLeftSlot?: React.ReactNode;
   interactiveMessages: InteractiveMessage[];
   intentThreadId: string | null;
   intentReady: object | null;
@@ -93,6 +98,7 @@ export interface Step1PanelProps {
 
 export function Step1Panel(props: Step1PanelProps) {
   const {
+    headerLeftSlot,
     interactiveMessages,
     intentThreadId,
     intentReady,
@@ -157,14 +163,16 @@ export function Step1Panel(props: Step1PanelProps) {
   return (
     <div className="flex-1 flex flex-col min-h-0">
       {/* Dialogue Header */}
-      <div ref={headerDzRef} className="shrink-0 px-6 py-4.5 border-b border-slate-100 flex items-center justify-between bg-slate-50/50">
-        <div className="flex items-center gap-2">
-          <MessageSquare className="w-4.5 h-4.5 text-primary" strokeWidth={2.5} />
-          <h3 className="text-sm font-extrabold text-slate-900">
-            任务意图理解 (人机问答)
-          </h3>
-        </div>
-        <span className="text-[11px] font-bold text-slate-400 bg-white border px-2 py-0.5 rounded-md">
+      <div ref={headerDzRef} className="shrink-0 px-6 py-4.5 border-b border-slate-100 flex items-center justify-between gap-3 bg-slate-50/50">
+        {headerLeftSlot ?? (
+          <div className="flex items-center gap-2">
+            <MessageSquare className="w-4.5 h-4.5 text-primary" strokeWidth={2.5} />
+            <h3 className="text-sm font-extrabold text-slate-900">
+              任务意图理解 (人机问答)
+            </h3>
+          </div>
+        )}
+        <span className="shrink-0 text-[11px] font-bold text-slate-400 bg-white border px-2 py-0.5 rounded-md">
           问答轮次：{interactiveMessages.filter((m) => m.sender === "user").length} 轮
         </span>
       </div>
@@ -173,7 +181,8 @@ export function Step1Panel(props: Step1PanelProps) {
       <div className="relative flex-1 min-h-0 flex flex-col font-normal">
         <div
           ref={step1ScrollRef}
-          className="flex-1 min-h-0 overflow-y-auto p-6 space-y-4 bg-white"
+          // overflow-x-hidden：消息列表只竖向滚（见 Step2Panel 同处注释），避免误触横向拖动抢滑块。
+          className="flex-1 min-h-0 overflow-y-auto overflow-x-hidden p-6 space-y-4 bg-white"
         >
           {interactiveMessages.map((msg) => (
             <Step1Message

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

@@ -551,7 +551,11 @@ export function Step2Panel(props: Step2PanelProps) {
         )}
         <div
           ref={step2ScrollRef}
-          className="flex-1 min-h-0 overflow-y-auto p-6 space-y-4 bg-white border-t border-slate-150 border-b border-slate-150 shadow-inner"
+          // overflow-x-hidden：消息列表只竖向滚。否则 `overflow-y-auto` 单写时按 CSS 规范
+          // 另一轴会被计算成 auto，任何子元素溢出一两像素都会让整列横向可滚 → 鼠标移到右侧
+          // 竖滚条滑块时极易误触发横向拖动、抓不住滑块。宽内容（代码块/表格）在各自气泡内
+          // 已有 max-w-full + overflow-x-auto 自带横滚，故此处裁掉横向不影响查看。
+          className="flex-1 min-h-0 overflow-y-auto overflow-x-hidden p-6 space-y-4 bg-white border-t border-slate-150 border-b border-slate-150 shadow-inner"
         >
           {isInitializing && step2RoundtableDialogues.length === 0 && (
             <div className="flex h-full flex-col items-center justify-center gap-3 py-12 text-slate-500">

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

@@ -15,9 +15,7 @@
 import {
   useEffect,
   useMemo,
-  useRef,
   useState,
-  type FormEvent,
 } from "react";
 import {
   ArrowLeft,
@@ -27,31 +25,22 @@ import {
   ExternalLink,
   LayoutPanelTop,
   Loader2,
-  Pause,
   Pencil,
-  RefreshCw,
-  SendHorizontal,
   Sparkles,
 } from "lucide-react";
 
-import { useLocalSettings } from "@/core/settings";
-import { AutoGrowTextarea } from "@/components/ui/auto-grow-textarea";
 import { desensitizeDeep } from "@/lib/desensitize";
 import type { DraftStep3Snapshot } from "@/roundtable-planning/api/drafts";
 import { DashboardApp } from "@/roundtable-planning/dashboard/DashboardApp";
 import { adaptReportData } from "@/roundtable-planning/dashboard/data-context";
 import type { ModelOption } from "@/roundtable-planning/components/Step3ReportMode";
-import { ScrollToBottomButton } from "@/roundtable-planning/components/ScrollToBottomButton";
-import { Step2Message } from "@/roundtable-planning/components/Step2Panel";
+import { DashboardChatPanel } from "@/roundtable-planning/components/DashboardChatPanel";
 import { Step2SandboxLayout } from "@/roundtable-planning/components/Step2SandboxLayout";
 import { DASHBOARD_VIEW_STORAGE_PREFIX } from "@/roundtable-planning/pages/DashboardStandalonePage";
-import { useAutoScroll } from "@/roundtable-planning/hooks/useAutoScroll";
-import { useDialogueSpeedMetrics } from "@/roundtable-planning/hooks/useDialogueSpeedMetrics";
 import type { UseStep3DashboardReturn } from "@/roundtable-planning/hooks/useStep3Dashboard";
 import {
   parseReportJson,
   renderDashboardHtml,
-  stripReportFence,
   type DashboardTheme,
 } from "@/roundtable-planning/lib/report-template";
 import { useTheme } from "@/contexts/ThemeContext";
@@ -361,221 +350,3 @@ export function Step3DashboardMode({
     </div>
   );
 }
-
-// ── 交互区聊天面板（沙箱的左 60%；右 40% 是抽取过程代码预览） ──────────────────────────
-
-function DashboardChatPanel({
-  phase,
-  dialogues,
-  busy,
-  error,
-  onAsk,
-  onRedraw,
-  onPause,
-  onOpenPreview,
-  hasResult,
-  selectedModel,
-  availableModels,
-  modelsLoading,
-  setSelectedModel,
-}: {
-  phase: UseStep3DashboardReturn["phase"];
-  dialogues: UseStep3DashboardReturn["dialogues"];
-  busy: boolean;
-  error: string | null;
-  onAsk: (message: string) => void;
-  onRedraw: () => void;
-  onPause: () => void;
-  onOpenPreview: () => void;
-  hasResult: boolean;
-  selectedModel: string;
-  availableModels: ReadonlyArray<ModelOption>;
-  modelsLoading: boolean;
-  setSelectedModel: (model: string) => void;
-}) {
-  const inputLocked = phase === "creating";
-  const scrollRef = useRef<HTMLDivElement>(null);
-  const { atBottom, scrollToBottom } = useAutoScroll(scrollRef, [dialogues]);
-  const [localSettings] = useLocalSettings();
-  const speedMeterEnabled = localSettings.display.streamSpeedMeterEnabled;
-  const dialogueMetrics = useDialogueSpeedMetrics(dialogues);
-  const [text, setText] = useState("");
-
-  // 消息列表里不展示 report-json 结构化数据本体（它已在右侧沙箱实时渲染），
-  // 把数据块替换成一句「看右侧沙箱」的提示，避免左右两边重复刷整段 JSON。
-  const displayDialogues = useMemo(
-    () =>
-      dialogues.map((d) => {
-        const content = d.content ?? "";
-        if (!content) return d;
-        const stripped = stripReportFence(content, d.streaming === true);
-        return stripped === content ? d : { ...d, content: stripped };
-      }),
-    [dialogues],
-  );
-
-  const handleSubmit = (e: FormEvent<HTMLFormElement>) => {
-    e.preventDefault();
-    const t = text.trim();
-    if (!t || inputLocked) return;
-    setText("");
-    onAsk(t);
-  };
-
-  return (
-    <div className="flex h-full min-h-0 flex-col bg-slate-50/20">
-      {/* 面板头：智能体名 + 模型选择 + 暂停/重画 */}
-      <div className="shrink-0 flex items-center justify-between gap-2 border-b border-slate-100 bg-white px-4 py-2.5">
-        <div className="flex items-center gap-2 min-w-0">
-          <div className="w-6 h-6 shrink-0 rounded-lg bg-gradient-to-tr from-primary to-[var(--brand-200)] flex items-center justify-center text-white text-xs shadow-sm">
-            📊
-          </div>
-          <div className="leading-tight min-w-0">
-            <div className="text-xs font-bold text-slate-800 truncate">大屏绘制智能体</div>
-            <div className="text-[10px] text-slate-400 truncate">提炼研讨成果为大屏结构化数据（右侧实时显示抽取过程）</div>
-          </div>
-        </div>
-        <div className="flex items-center gap-2 shrink-0">
-          <select
-            id="step3-dashboard-model-select"
-            value={selectedModel}
-            onChange={(e) => setSelectedModel(e.target.value)}
-            disabled={busy || modelsLoading || availableModels.length === 0}
-            title={
-              modelsLoading
-                ? "正在加载模型列表…"
-                : availableModels.length === 0
-                  ? "未在 config.yaml 中配置任何模型"
-                  : busy
-                    ? "绘制中不可切换；完成后或重新绘制时生效"
-                    : "切换绘制使用的推理模型（下次绘制生效）"
-            }
-            className="max-w-[160px] bg-slate-50/50 border border-slate-200 rounded-xl px-2.5 py-1.5 text-[11px] font-bold text-slate-700 cursor-pointer focus:outline-none focus:border-primary focus:ring-1 focus:ring-[var(--brand-200)]/50 disabled:opacity-50 disabled:cursor-not-allowed dark:bg-secondary dark:text-foreground dark:border-border"
-          >
-            {availableModels.length === 0 && (
-              <option value="">{modelsLoading ? "加载中…" : "未配置模型"}</option>
-            )}
-            {availableModels.map((m) => (
-              <option key={m.name} value={m.name}>
-                {m.display_name && m.display_name !== m.name ? `${m.display_name} (${m.name})` : m.name}
-              </option>
-            ))}
-          </select>
-          {busy ? (
-            <button
-              type="button"
-              onClick={onPause}
-              title="中止当前绘制"
-              className="bg-white border border-amber-200 text-amber-700 hover:bg-amber-50 text-[10.5px] font-bold px-2.5 py-1.5 rounded-xl flex items-center gap-1 transition"
-            >
-              <Pause className="w-3.5 h-3.5" />
-              中止
-            </button>
-          ) : (
-            <button
-              type="button"
-              onClick={onRedraw}
-              title="丢弃上下文，从头重新绘制"
-              className="bg-white border border-slate-200 text-slate-700 hover:bg-slate-50 text-[10.5px] font-bold px-2.5 py-1.5 rounded-xl flex items-center gap-1 transition"
-            >
-              <RefreshCw className="w-3.5 h-3.5 text-slate-500" />
-              重新绘制
-            </button>
-          )}
-        </div>
-      </div>
-
-      {/* 聊天记录 */}
-      <div className="relative flex-1 min-h-0 flex flex-col">
-        <div ref={scrollRef} className="flex-1 min-h-0 overflow-y-auto p-4 space-y-4 bg-white">
-          {phase === "creating" && dialogues.length === 0 && (
-            <div className="flex items-center gap-2 text-xs text-slate-500">
-              <Loader2 className="w-3.5 h-3.5 animate-spin text-primary" />
-              正在初始化绘制线程…
-            </div>
-          )}
-
-          {displayDialogues.map((msg) => (
-            <Step2Message
-              key={msg.id}
-              msg={msg}
-              metric={speedMeterEnabled ? dialogueMetrics.get(msg.id) : undefined}
-            />
-          ))}
-
-          {busy && (
-            <div className="inline-flex items-center gap-2 rounded-full border bg-white px-2.5 py-1 text-[11px] text-slate-500">
-              <span className="bg-primary size-1.5 animate-pulse rounded-full" />
-              右侧沙箱实时显示数据抽取过程，完成后自动切到大屏页面
-            </div>
-          )}
-
-          {phase === "error" && (
-            <div className="rounded-xl border border-rose-200 bg-rose-50 p-3 text-xs text-rose-700">
-              <div className="font-bold mb-1">绘制失败</div>
-              <div className="leading-relaxed break-all">{error}</div>
-              <button
-                type="button"
-                onClick={onRedraw}
-                className="mt-2 inline-flex items-center gap-1 text-[11px] font-bold text-rose-700 underline hover:text-rose-800"
-              >
-                <RefreshCw className="w-3 h-3" />
-                重试
-              </button>
-            </div>
-          )}
-
-          {phase === "done" && (
-            <div className="flex items-center gap-2 text-xs font-bold text-emerald-600">
-              <CheckCircle className="w-4 h-4" />
-              数据已就绪，已切换到大屏页面。
-              {hasResult && (
-                <button
-                  type="button"
-                  onClick={onOpenPreview}
-                  className="ml-1 inline-flex items-center gap-1 text-[11px] font-bold text-primary underline hover:opacity-80"
-                >
-                  在沙箱打开 HTML 预览
-                </button>
-              )}
-            </div>
-          )}
-        </div>
-        {!atBottom && <ScrollToBottomButton onClick={scrollToBottom} />}
-
-        {/* 问答修改输入框 */}
-        <form onSubmit={handleSubmit} className="shrink-0 border-t border-slate-100 bg-white px-3 py-3">
-          <div className="flex items-end gap-2 rounded-2xl border border-slate-200 bg-slate-50/70 px-3 py-2 focus-within:border-primary/60 focus-within:bg-white focus-within:ring-2 focus-within:ring-[var(--brand-200)]/40">
-            <AutoGrowTextarea
-              maxHeight={224}
-              value={text}
-              onChange={(e) => setText(e.target.value)}
-              onKeyDown={(e) => {
-                if (e.key === "Enter" && !e.shiftKey) {
-                  e.preventDefault();
-                  e.currentTarget.form?.requestSubmit();
-                }
-              }}
-              disabled={inputLocked}
-              rows={1}
-              placeholder={
-                busy
-                  ? "随时输入修改要求——发送会打断当前绘制并按新要求重出数据"
-                  : "输入修改要求，例如：把风险分布换成柱状图，新增一个执行路线席位"
-              }
-              className="min-h-8 max-h-56 flex-1 resize-none bg-transparent py-1.5 text-xs leading-relaxed text-slate-800 placeholder:text-slate-400 focus:outline-none disabled:cursor-not-allowed disabled:opacity-60"
-            />
-            <button
-              type="submit"
-              disabled={inputLocked || text.trim().length === 0}
-              title={inputLocked ? "正在初始化线程，请稍候" : "发送修改要求"}
-              className="mb-0.5 flex h-8 w-8 shrink-0 items-center justify-center rounded-xl bg-primary text-white transition hover:bg-[var(--brand-900)] disabled:cursor-not-allowed disabled:opacity-50"
-            >
-              {inputLocked ? <Loader2 className="h-4 w-4 animate-spin" /> : <SendHorizontal className="h-4 w-4" />}
-            </button>
-          </div>
-        </form>
-      </div>
-    </div>
-  );
-}

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

@@ -592,7 +592,7 @@ function AgentProgressPanel({
       <div className="relative flex-1 min-h-0 flex flex-col">
         <div
           ref={scrollRef}
-          className="flex-1 min-h-0 overflow-y-auto p-4 space-y-4 bg-white"
+          className="flex-1 min-h-0 overflow-y-auto overflow-x-hidden p-4 space-y-4 bg-white"
         >
           {phase === "creating" && dialogues.length === 0 && (
             <div className="flex items-center gap-2 text-xs text-slate-500">

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

@@ -10,11 +10,13 @@
  * 互不影响（report 画 HTML 看板，summary 写 Markdown 报告 + 问答）。
  */
 import { useEffect, useMemo, useRef, useState, type FormEvent } from "react";
+import { createPortal } from "react-dom";
 import ReactMarkdown from "react-markdown";
 import remarkGfm from "remark-gfm";
 import {
   ArrowRight,
   CheckCircle,
+  Database,
   Download,
   Eye,
   FileText,
@@ -46,7 +48,6 @@ import { FlowGraphPanel } from "@/roundtable-planning/components/FlowGraphPanel"
 import {
   detectFlowIntent,
   extractFlowGraph,
-  stripFlowFence,
   FLOW_FENCE_OPEN,
 } from "@/roundtable-planning/lib/flow-graph";
 import { ScrollToBottomButton } from "@/roundtable-planning/components/ScrollToBottomButton";
@@ -139,9 +140,18 @@ export function Step3SummaryMode({
 
   const { open: artifactsOpen } = useArtifacts();
 
-  // ── 结构化流程图：流式提取回复末尾的 flow-json，增量绘制 ──────────────────
-  // 取最后一条含 flow-json 的智能体气泡（多轮修改后以最新一份为准）。
+  // ── 结构化流程图（Phase 1：后端「抽取+校验」）────────────────────────────
+  // 数据来源优先级：
+  //  · flowPhase==="done" → 用后端校验后的结构化图 summary.flowGraph 绘制；
+  //  · 抽取/校验进行中 → 不画（用户看对话气泡里实时滚动的 JSON + 状态条），等校验完成再绘制；
+  //  · idle/error → 回退到对话气泡里解析 flow-json（手动 flow 续问路径 / 旧逻辑兜底）。
   const flowGraph = useMemo(() => {
+    if (summary.flowPhase === "done" && summary.flowGraph) {
+      return { graph: summary.flowGraph, streaming: false };
+    }
+    if (summary.flowPhase === "extracting" || summary.flowPhase === "validating") {
+      return null;
+    }
     for (let i = dialogues.length - 1; i >= 0; i--) {
       const d = dialogues[i];
       if (d.avatarType === "human") continue;
@@ -151,7 +161,7 @@ export function Step3SummaryMode({
       if (graph) return { graph, streaming: d.streaming === true };
     }
     return null;
-  }, [dialogues]);
+  }, [dialogues, summary.flowPhase, summary.flowGraph]);
 
   const [flowView, setFlowView] = useState(false);
   const flowAutoOpenedRef = useRef(false);
@@ -196,16 +206,10 @@ export function Step3SummaryMode({
     ask(message, files);
   };
 
-  // 气泡里不展示生 JSON：把 flow-json 块替换成一句引导语。
-  const displayDialogues = useMemo(
-    () =>
-      dialogues.map((d) => {
-        const content = d.content ?? "";
-        if (!content.includes(FLOW_FENCE_OPEN)) return d;
-        return { ...d, content: stripFlowFence(content, d.streaming === true) };
-      }),
-    [dialogues],
-  );
+  // 流程图抽取/校验的过程（思考 `<think>` + 文字说明 + flow-json 代码块）全部原样交给
+  // Step2Message 渲染：它用 splitInlineReasoning 把思考折叠成思考块、其余按 markdown 渲染
+  // （flow-json 显示为代码块）。用户要求显示完整过程、不只显示代码块，故不再 strip。
+  const displayDialogues = dialogues;
   const [leftCollapsed, setLeftCollapsed] = useState(false);
   // 右侧面板（沙箱预览或流程图画布）露出时自动收起左栏，关闭时复原——边沿触发，手动切换不回弹。
   const rightPanelVisible = artifactsOpen || (!!flowGraph && flowView);
@@ -397,6 +401,7 @@ export function Step3SummaryMode({
                         }
                       : undefined
                   }
+                  onChange={summary.setFlowGraph}
                 />
               ) : undefined
             }
@@ -407,6 +412,18 @@ export function Step3SummaryMode({
               error={error}
               busy={busy}
               mdAvailable={!!mdArtifact}
+              flowPhase={summary.flowPhase}
+              onRegenerateFlow={summary.regenerateFlow}
+              pendingClarification={summary.pendingFlowClarification}
+              onResolveClarification={summary.resolveFlowClarification}
+              ingestAvailable={summary.ingestAvailable}
+              ingestStatus={summary.ingestStatus}
+              pendingIngestClarification={summary.pendingIngestClarification}
+              onResolveIngestChoice={summary.resolveIngestChoice}
+              onResolveIngestClarification={summary.resolveIngestClarification}
+              pendingFlowForIngest={summary.pendingFlowForIngest}
+              onResolveFlowForIngest={summary.resolveFlowForIngest}
+              onManualIngest={summary.runIngest}
               onRetry={redraw}
               onAsk={handleAsk}
               onPause={pause}
@@ -549,6 +566,18 @@ function AgentProgressPanel({
   error,
   busy,
   mdAvailable,
+  flowPhase,
+  onRegenerateFlow,
+  pendingClarification,
+  onResolveClarification,
+  ingestAvailable,
+  ingestStatus,
+  pendingIngestClarification,
+  onResolveIngestChoice,
+  onResolveIngestClarification,
+  pendingFlowForIngest,
+  onResolveFlowForIngest,
+  onManualIngest,
   onRetry,
   onAsk,
   onPause,
@@ -565,6 +594,23 @@ function AgentProgressPanel({
   busy: boolean;
   /** 沙箱里是否已有 md 报告 —— 决定提示语（纯流程图轮没有 .md 可预览/下载）。 */
   mdAvailable: boolean;
+  /** 后端流程图抽取阶段（Phase 1）。 */
+  flowPhase: UseStep3SummaryReturn["flowPhase"];
+  /** 仅重新生成流程图（模型挂了切模型后重试）。 */
+  onRegenerateFlow: () => void;
+  /** 意图模糊待澄清的原始消息（非空 → 展示选项让用户定）。 */
+  pendingClarification: string | null;
+  onResolveClarification: UseStep3SummaryReturn["resolveFlowClarification"];
+  /** 入库技能是否可用（决定入库询问卡 + 手动入库按钮是否出现）。 */
+  ingestAvailable: boolean;
+  ingestStatus: UseStep3SummaryReturn["ingestStatus"];
+  pendingIngestClarification: string | null;
+  onResolveIngestChoice: UseStep3SummaryReturn["resolveIngestChoice"];
+  onResolveIngestClarification: UseStep3SummaryReturn["resolveIngestClarification"];
+  /** 入库时尚无流程图 → 展示「是否先生成流程图」协助。 */
+  pendingFlowForIngest: boolean;
+  onResolveFlowForIngest: UseStep3SummaryReturn["resolveFlowForIngest"];
+  onManualIngest: UseStep3SummaryReturn["runIngest"];
   onRetry: () => void;
   onAsk: (message: string, files?: File[]) => void;
   onPause: () => void;
@@ -661,7 +707,7 @@ function AgentProgressPanel({
 
       {/* 消息列表 —— 与第 2 步同款气泡（流式正文 + 工具步骤卡 + 文件卡）。 */}
       <div className="relative flex-1 min-h-0 flex flex-col">
-        <div ref={scrollRef} className="flex-1 min-h-0 overflow-y-auto p-4 space-y-4 bg-white">
+        <div ref={scrollRef} className="flex-1 min-h-0 overflow-y-auto overflow-x-hidden p-4 space-y-4 bg-white">
           {phase === "creating" && dialogues.length === 0 && (
             <div className="flex items-center gap-2 text-xs text-slate-500">
               <Loader2 className="w-3.5 h-3.5 animate-spin text-primary" />
@@ -705,6 +751,28 @@ function AgentProgressPanel({
             </div>
           )}
 
+          {/* 后端流程图「抽取+校验」状态条（Phase 1）。 */}
+          {(flowPhase === "extracting" || flowPhase === "validating") && (
+            <div className="inline-flex items-center gap-2 rounded-full border border-blue-200 bg-blue-50 px-2.5 py-1 text-[11px] font-bold text-blue-600">
+              <Loader2 className="w-3 h-3 animate-spin" />
+              {flowPhase === "extracting" ? "结构化流程图抽取中（JSON 实时输出）…" : "流程图校验 / 修复中…"}
+            </div>
+          )}
+          {flowPhase === "error" && (
+            <div className="rounded-xl border border-amber-200 bg-amber-50 p-3 text-xs text-amber-800">
+              <div className="font-bold mb-1">流程图生成失败</div>
+              <div className="leading-relaxed">模型可能不稳定。可在上方切换模型后重试。</div>
+              <button
+                type="button"
+                onClick={onRegenerateFlow}
+                className="mt-2 inline-flex items-center gap-1 text-[11px] font-bold text-amber-800 underline hover:text-amber-900"
+              >
+                <RefreshCw className="w-3 h-3" />
+                重新生成流程图
+              </button>
+            </div>
+          )}
+
           {phase === "done" && (
             <div className="flex items-center gap-2 text-xs font-bold text-emerald-600">
               <CheckCircle className="w-4 h-4" />
@@ -715,6 +783,115 @@ function AgentProgressPanel({
           )}
         </div>
         {!atBottom && <ScrollToBottomButton onClick={scrollToBottom} />}
+
+        {/* 意图模糊 → 让用户自己定（不自作主张） */}
+        {pendingClarification && (
+          <div className="shrink-0 border-t border-amber-100 bg-amber-50/60 px-3 py-2.5">
+            <div className="mb-1.5 text-[11px] font-bold text-amber-800">
+              没太理解你的意思，你是想——
+            </div>
+            <div className="flex flex-wrap gap-1.5">
+              {(
+                [
+                  { k: "regenerate_report", t: "重新生成报告" },
+                  { k: "modify_flow", t: "修改流程图" },
+                  { k: "regenerate_flow", t: "重新生成流程图" },
+                  { k: "qa", t: "只是提问" },
+                ] as const
+              ).map((o) => (
+                <button
+                  key={o.k}
+                  type="button"
+                  onClick={() => onResolveClarification(o.k)}
+                  className="rounded-lg border border-amber-300 bg-white px-2.5 py-1.5 text-[11px] font-bold text-amber-800 transition hover:bg-amber-100"
+                >
+                  {o.t}
+                </button>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* 流程图已生成 → 询问是否入库（入库技能可用时）。 */}
+        {ingestAvailable && ingestStatus === "asking" && (
+          <div className="shrink-0 border-t border-emerald-100 bg-emerald-50/60 px-3 py-2.5">
+            <div className="mb-1.5 text-[11px] font-bold text-emerald-800">
+              流程图已生成，是否进行数据入库？
+            </div>
+            <div className="flex flex-wrap gap-1.5">
+              {(
+                [
+                  { k: "now", t: "现在入库" },
+                  { k: "later", t: "稍后入库" },
+                  { k: "never", t: "不入库" },
+                ] as const
+              ).map((o) => (
+                <button
+                  key={o.k}
+                  type="button"
+                  onClick={() => onResolveIngestChoice(o.k)}
+                  className="rounded-lg border border-emerald-300 bg-white px-2.5 py-1.5 text-[11px] font-bold text-emerald-800 transition hover:bg-emerald-100"
+                >
+                  {o.t}
+                </button>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* 入库时尚无流程图 → 协助：数据入库以流程图为核心内容，先问是否生成流程图。 */}
+        {ingestAvailable && pendingFlowForIngest && (
+          <div className="shrink-0 border-t border-amber-100 bg-amber-50/70 px-3 py-2.5">
+            <div className="mb-1.5 text-[11px] font-bold text-amber-800">
+              当前还没有生成流程图，数据入库需要流程图。是否先生成流程图？
+            </div>
+            <div className="flex flex-wrap gap-1.5">
+              {(
+                [
+                  { k: "generate", t: "生成流程图" },
+                  { k: "cancel", t: "暂不入库" },
+                ] as const
+              ).map((o) => (
+                <button
+                  key={o.k}
+                  type="button"
+                  onClick={() => onResolveFlowForIngest(o.k)}
+                  className="rounded-lg border border-amber-300 bg-white px-2.5 py-1.5 text-[11px] font-bold text-amber-800 transition hover:bg-amber-100"
+                >
+                  {o.t}
+                </button>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* 「稍后入库」自由文字意图模糊 → 让用户在入库语境下自己定。 */}
+        {ingestAvailable && pendingIngestClarification && (
+          <div className="shrink-0 border-t border-emerald-100 bg-emerald-50/60 px-3 py-2.5">
+            <div className="mb-1.5 text-[11px] font-bold text-emerald-800">
+              没太理解你的入库意思，你是想——
+            </div>
+            <div className="flex flex-wrap gap-1.5">
+              {(
+                [
+                  { k: "start_ingest", t: "开始入库" },
+                  { k: "add_data", t: "补充内容后再入库" },
+                  { k: "other", t: "只是提问 / 改报告" },
+                ] as const
+              ).map((o) => (
+                <button
+                  key={o.k}
+                  type="button"
+                  onClick={() => onResolveIngestClarification(o.k)}
+                  className="rounded-lg border border-emerald-300 bg-white px-2.5 py-1.5 text-[11px] font-bold text-emerald-800 transition hover:bg-emerald-100"
+                >
+                  {o.t}
+                </button>
+              ))}
+            </div>
+          </div>
+        )}
+
         <form onSubmit={handleAskSubmit} className="shrink-0 border-t border-slate-100 bg-white px-3 py-3">
           {/* 已选附件预览（发送时随指令上传到总结线程，供智能体读取） */}
           {askFiles.length > 0 && (
@@ -761,6 +938,22 @@ function AgentProgressPanel({
               className="min-h-8 max-h-56 flex-1 resize-none bg-transparent py-1.5 text-xs leading-relaxed text-slate-800 placeholder:text-slate-400 focus:outline-none"
             />
 
+            {/* 手动入库（入库技能可用、且已过流程图询问阶段时显示）：直接在总结线程跑入库技能。 */}
+            {ingestAvailable &&
+              ingestStatus !== "asking" &&
+              ingestStatus !== "running" &&
+              ingestStatus !== "idle" && (
+                <button
+                  type="button"
+                  onClick={() => onManualIngest()}
+                  title="进行数据入库（由结构化输出智能体调用入库技能，过程见消息列表步骤条）"
+                  className="mb-0.5 flex h-8 shrink-0 items-center gap-1 rounded-xl border border-emerald-200 bg-emerald-50 px-2.5 text-[11px] font-bold text-emerald-700 transition hover:bg-emerald-100 active:scale-95"
+                >
+                  <Database className="h-3.5 w-3.5" />
+                  数据入库
+                </button>
+              )}
+
             {/* 上传文件（参考第一/二步：本地选取，发送时上传到总结线程） */}
             <input ref={fileInputRef} type="file" multiple className="hidden" onChange={pickFiles} />
             <button
@@ -813,7 +1006,10 @@ function ContentModal({
   onClose: () => void;
   headerAction?: React.ReactNode;
 }) {
-  return (
+  // 经 portal 挂到 body：页面 <main> 是 `relative z-0`（浅蓝主题层叠基线），会把
+  // 内部 fixed 弹窗困在 z-0 层叠上下文里，被会商页头(z-40)/全局顶栏(z-45)盖住顶部。
+  // 挂到 body 后脱离该上下文，z-50 才真正盖在顶栏之上，弹窗标题栏正常显示。
+  return createPortal(
     <div
       className="fixed inset-0 z-50 flex items-center justify-center bg-black/40 backdrop-blur-[1px] p-4"
       onClick={onClose}
@@ -837,7 +1033,8 @@ function ContentModal({
         </div>
         <div className="flex-1 overflow-y-auto p-5">{children}</div>
       </div>
-    </div>
+    </div>,
+    document.body,
   );
 }
 

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

@@ -24,14 +24,22 @@ import {
   deleteDraft,
   deriveDraftName,
   getDraft,
-  getLatestDraftByTask,
   listDrafts,
-  listDraftsByTask,
   updateDraft,
+  type DraftCreatePayload,
   type DraftRecord,
   type DraftStep2Snapshot,
   type DraftStep3Snapshot,
+  type DraftUpdatePayload,
 } from "@/roundtable-planning/api/drafts";
+import {
+  createTaskDraft,
+  deleteTaskDraft,
+  getLatestTaskDraftByTask,
+  getTaskDraft,
+  listTaskDraftsByTask,
+  updateTaskDraft,
+} from "@/roundtable-planning/api/task-drafts";
 import type { JobStatus } from "@/roundtable-planning/lib/job-types";
 
 /** 历史下拉渲染用的轻量列表项（`name` 映射自后端 `title`）。 */
@@ -157,6 +165,27 @@ export function useDraftPersistence(
     taskIdRef.current = taskId ?? null;
   }, [taskId]);
 
+  // taskId 模式下所有 CRUD 走**独立的 task-draft 存储**（不分权）；否则走个人草稿存储。
+  // 读 taskIdRef.current（而非闭包捕获）以在 render 前拿到最新值。
+  const apiCreate = useCallback(
+    (payload: DraftCreatePayload): Promise<DraftRecord> =>
+      taskIdRef.current ? createTaskDraft(payload) : createDraft(payload),
+    [],
+  );
+  const apiUpdate = useCallback(
+    (id: string, patch: DraftUpdatePayload): Promise<DraftRecord | null> =>
+      taskIdRef.current ? updateTaskDraft(id, patch) : updateDraft(id, patch),
+    [],
+  );
+  const apiGet = useCallback(
+    (id: string): Promise<DraftRecord | null> => (taskIdRef.current ? getTaskDraft(id) : getDraft(id)),
+    [],
+  );
+  const apiDelete = useCallback(
+    (id: string): Promise<void> => (taskIdRef.current ? deleteTaskDraft(id) : deleteDraft(id)),
+    [],
+  );
+
   const [drafts, setDrafts] = useState<DraftListItem[]>([]);
   const [currentDraftId, setCurrentDraftIdState] = useState<string | null>(null);
   const [isHistoryOpen, setIsHistoryOpen] = useState<boolean>(false);
@@ -194,7 +223,7 @@ export function useDraftPersistence(
       // taskId 模式：历史下拉只列该任务的草稿（一个 taskId 多条记录、跨用户共享）；
       // 普通模式：列当前用户全部草稿。
       const tid = taskIdRef.current;
-      const metas = tid ? await listDraftsByTask(tid) : await listDrafts();
+      const metas = tid ? await listTaskDraftsByTask(tid) : await listDrafts();
       setDrafts(
         metas.map((m) => ({
           id: m.id,
@@ -244,7 +273,7 @@ export function useDraftPersistence(
 
         const id = currentDraftIdRef.current;
         if (id) {
-          const updated = await updateDraft(id, {
+          const updated = await apiUpdate(id, {
             ...(furthestStep !== undefined ? { furthestStep } : {}),
             step1,
             step2,
@@ -253,7 +282,7 @@ export function useDraftPersistence(
           if (updated) return updated.id;
           // 服务端已不存在（被删/换账号）→ 落回新建。
         }
-        const created = await createDraft({
+        const created = await apiCreate({
           ...(taskIdRef.current ? { taskId: taskIdRef.current } : {}),
           title: deriveDraftName({
             intentReady: step1.intentReady,
@@ -272,7 +301,7 @@ export function useDraftPersistence(
       saveQueueRef.current = next.catch(() => undefined);
       return next as Promise<string | null>;
     },
-    [getStep1Snapshot, getStep2Snapshot, getStep3Snapshot, hasSavableContent, setCurrentDraftId],
+    [apiCreate, apiUpdate, getStep1Snapshot, getStep2Snapshot, getStep3Snapshot, hasSavableContent, setCurrentDraftId],
   );
 
   const ensureDraft = useCallback(
@@ -311,7 +340,7 @@ export function useDraftPersistence(
       const run = async (): Promise<string | null> => {
         const id = currentDraftIdRef.current;
         if (id) {
-          const updated = await updateDraft(id, { furthestStep, step2 });
+          const updated = await apiUpdate(id, { furthestStep, step2 });
           if (updated) {
             currentDraftIdRef.current = updated.id;
             return updated.id;
@@ -320,7 +349,7 @@ export function useDraftPersistence(
         }
         const step1 = getStep1Snapshot();
         if (!hasSavableContent(step1, step2)) return null;
-        const created = await createDraft({
+        const created = await apiCreate({
           ...(taskIdRef.current ? { taskId: taskIdRef.current } : {}),
           title: deriveDraftName({
             intentReady: step1.intentReady,
@@ -338,7 +367,7 @@ export function useDraftPersistence(
       saveQueueRef.current = next.catch(() => undefined);
       return next as Promise<string | null>;
     },
-    [getStep1Snapshot, hasSavableContent, setCurrentDraftId],
+    [apiCreate, apiUpdate, getStep1Snapshot, hasSavableContent, setCurrentDraftId],
   );
 
   const handleManualSave = useCallback(() => {
@@ -458,7 +487,7 @@ export function useDraftPersistence(
       return (async () => {
         let draft;
         try {
-          draft = await getDraft(id);
+          draft = await apiGet(id);
         } catch (err) {
           console.warn("[drafts] 加载草稿失败:", err);
           triggerToast("⚠️ 加载草稿失败,请重试");
@@ -473,7 +502,7 @@ export function useDraftPersistence(
         return true;
       })();
     },
-    [applyLoadedDraft, refreshList, triggerToast],
+    [apiGet, applyLoadedDraft, refreshList, triggerToast],
   );
 
   /**
@@ -484,7 +513,7 @@ export function useDraftPersistence(
     async (tid: string): Promise<boolean> => {
       let draft: DraftRecord | null = null;
       try {
-        draft = await getLatestDraftByTask(tid);
+        draft = await getLatestTaskDraftByTask(tid);
       } catch (err) {
         console.warn("[drafts] 按任务加载草稿失败:", err);
         return false;
@@ -503,7 +532,7 @@ export function useDraftPersistence(
       }
       void (async () => {
         try {
-          await deleteDraft(id);
+          await apiDelete(id);
         } catch (err) {
           console.warn("[drafts] 删除草稿失败:", err);
           triggerToast("⚠️ 删除失败,请重试");
@@ -515,7 +544,7 @@ export function useDraftPersistence(
         triggerToast("🗑 已删除历史记录");
       })();
     },
-    [refreshList, renamingDraftId, setCurrentDraftId, triggerToast],
+    [apiDelete, refreshList, renamingDraftId, setCurrentDraftId, triggerToast],
   );
 
   const handleStartRename = useCallback((draft: DraftListItem) => {
@@ -534,7 +563,7 @@ export function useDraftPersistence(
       void (async () => {
         try {
           // 只发 title —— 与自动保存的「不带 title」互补,重命名是唯一改标题的入口。
-          const updated = await updateDraft(id, { title: trimmed });
+          const updated = await apiUpdate(id, { title: trimmed });
           if (updated) {
             await refreshList();
             triggerToast("✏️ 已重命名");
@@ -548,7 +577,7 @@ export function useDraftPersistence(
         }
       })();
     },
-    [refreshList, renameDraftValue, triggerToast],
+    [apiUpdate, refreshList, renameDraftValue, triggerToast],
   );
 
   const handleCancelRename = useCallback(() => {

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

@@ -11,14 +11,18 @@ import { useCallback, useState } from "react";
 import {
   deleteDraft,
   listDrafts,
-  listDraftsByTask,
   updateDraft,
   type DraftMeta,
 } from "@/roundtable-planning/api/drafts";
+import {
+  deleteTaskDraft,
+  listTaskDraftsByTask,
+  updateTaskDraft,
+} from "@/roundtable-planning/api/task-drafts";
 
 /**
- * @param taskId 外部任务 id（深链 taskId 模式）。非空时只列该任务的草稿
- *   （一个 taskId 多条、跨用户共享）；否则列当前用户全部草稿。
+ * @param taskId 外部任务 id（深链 taskId 模式）。非空时走**独立的 task-draft 存储**
+ *   （一个 taskId 多条、跨用户共享、不分权）；否则列当前用户全部个人草稿。
  */
 export function useRoundtableDrafts(taskId?: string | null) {
   const [drafts, setDrafts] = useState<DraftMeta[]>([]);
@@ -27,7 +31,7 @@ export function useRoundtableDrafts(taskId?: string | null) {
   const refresh = useCallback(async () => {
     setLoading(true);
     try {
-      const data = taskId ? await listDraftsByTask(taskId) : await listDrafts();
+      const data = taskId ? await listTaskDraftsByTask(taskId) : await listDrafts();
       setDrafts(data);
     } catch {
       // 历史记录非关键，静默忽略
@@ -36,20 +40,25 @@ export function useRoundtableDrafts(taskId?: string | null) {
     }
   }, [taskId]);
 
-  const rename = useCallback(async (id: string, title: string) => {
-    // 只发 title —— 与页面自动保存的「不带 title」互补，是改标题的唯一入口。
-    const updated = await updateDraft(id, { title });
-    if (updated) {
-      setDrafts((prev) =>
-        prev.map((d) => (d.id === id ? { ...d, title: updated.title } : d)),
-      );
-    }
-  }, []);
+  const rename = useCallback(
+    async (id: string, title: string) => {
+      // 只发 title —— 与页面自动保存的「不带 title」互补，是改标题的唯一入口。
+      const updated = taskId ? await updateTaskDraft(id, { title }) : await updateDraft(id, { title });
+      if (updated) {
+        setDrafts((prev) => prev.map((d) => (d.id === id ? { ...d, title: updated.title } : d)));
+      }
+    },
+    [taskId],
+  );
 
-  const remove = useCallback(async (id: string) => {
-    await deleteDraft(id);
-    setDrafts((prev) => prev.filter((d) => d.id !== id));
-  }, []);
+  const remove = useCallback(
+    async (id: string) => {
+      if (taskId) await deleteTaskDraft(id);
+      else await deleteDraft(id);
+      setDrafts((prev) => prev.filter((d) => d.id !== id));
+    },
+    [taskId],
+  );
 
   return { drafts, loading, refresh, rename, remove };
 }

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

@@ -20,6 +20,7 @@ import { useArtifacts } from "@/components/workspace/artifacts";
 import {
   initMultiAgent,
   streamMultiAgent,
+  type ModelSwitchInfo,
   type ClarificationPayload,
   type LeaderDispatch,
   type StreamPhase,
@@ -279,6 +280,26 @@ export interface UseStep2OrchestrationOptions {
    * 智能体」弹窗确认时的 `SeatSelectionResult.seatMode` 决定。缺省 `pro`。
    */
   selectedMode: SeatMode;
+  /**
+   * 每席位「技能识别强化」开关映射 {agentId: bool}（沿用所选业务链条里每个席位的配置）。
+   * 按 agentId 查表后透传给该 special 席位 run，与该席位 agent 自身 config.yaml 的同名开关取
+   * OR。recommend / 未选链条 → 空 {}（各席位仅靠其自身开关）。
+   */
+  seatSkillDirectives?: Record<string, boolean>;
+  /**
+   * 每席位「推理深度覆盖」映射 {agentId: SeatMode | null}（沿用所选业务链条里每个席位的配置）。
+   * 派活该 special 席位时按 agentId 查表，**席位覆盖优先、否则跟随链条级 `selectedMode`**：
+   * `seatModeToRequestFields(seatModes[agentId] ?? selectedMode)`。模型卡顿时把次要席位降到
+   * `flash` 即可大幅提速。recommend / 未选链条 / 未覆盖 → 跟随 `selectedMode`。
+   */
+  seatModes?: Record<string, SeatMode | null>;
+  /**
+   * 「研讨前并行取数」开关（来源业务链条的 gatherFirst，逐条 opt-in，缺省 false）。true = 正式研讨
+   * 前先对**全席位并行**跑一轮「只取数」（各席位只调技能取数、不研讨），产出作为共享资料（peerDeliveries）
+   * 注入后续研讨轮，把最慢的技能检索前置并行、给（尤其 chain 串行的）研讨段提速。每轮研讨只在**本轮
+   * 研讨真正启动时**取数一次（resetInitGate 复位后下一轮再取），澄清续跑/干预不重复取数。
+   */
+  gatherFirst?: boolean;
   /**
    * 编排模式:
    *  - `recommend`(默认)—— 总控自由派活循环(`runOrchestration`);
@@ -434,6 +455,9 @@ export function useStep2Orchestration(
     currentStep,
     selectedModel,
     selectedMode,
+    seatSkillDirectives = {},
+    seatModes = {},
+    gatherFirst = false,
     orchestrationMode,
     orchestrationPlan,
     dagExecMode = "fast",
@@ -567,6 +591,16 @@ export function useStep2Orchestration(
   const selectedModelRef = useRef<string>(selectedModel);
   // 席位执行模式同样打到 ref，让席位调用在编排循环里读到最新值而不重建回调。
   const selectedModeRef = useRef<SeatMode>(selectedMode);
+  // 每席位技能识别强化映射（所选业务链条各席位开关）同样打到 ref，席位调用按 agentId 读最新值。
+  const seatSkillDirectivesRef = useRef<Record<string, boolean>>(seatSkillDirectives);
+  // 每席位推理深度覆盖映射（所选业务链条各席位 seatMode）打到 ref，席位调用按 agentId 读最新值；
+  // 覆盖优先、否则跟随 selectedModeRef。
+  const seatModesRef = useRef<Record<string, SeatMode | null>>(seatModes);
+  // 「研讨前并行取数」开关 + 本轮取数产物（{name,content}[]）+ 本轮是否已取过的闸门。取数产物作为
+  // peerDeliveries 注入研讨轮席位；闸门保证一轮研讨只取一次（resetInitGate / resetStep2State 复位）。
+  const gatherFirstRef = useRef<boolean>(gatherFirst);
+  const gatheredDeliveriesRef = useRef<Array<{ name: string; content: string }>>([]);
+  const gatherPhaseDoneRef = useRef<boolean>(false);
   const agentConfigsRef = useRef<Record<number, AgentConfig>>(agentConfigs);
   const agentNameToRoleRef = useRef(agentNameToRole);
   const threadIdsRef = useRef<ThreadIdMap | null>(threadIds);
@@ -606,6 +640,15 @@ export function useStep2Orchestration(
   useEffect(() => {
     selectedModeRef.current = selectedMode;
   }, [selectedMode]);
+  useEffect(() => {
+    seatSkillDirectivesRef.current = seatSkillDirectives;
+  }, [seatSkillDirectives]);
+  useEffect(() => {
+    seatModesRef.current = seatModes;
+  }, [seatModes]);
+  useEffect(() => {
+    gatherFirstRef.current = gatherFirst;
+  }, [gatherFirst]);
   useEffect(() => {
     agentConfigsRef.current = agentConfigs;
   }, [agentConfigs]);
@@ -1277,6 +1320,41 @@ export function useStep2Orchestration(
     );
   }, []);
 
+  /**
+   * 生成某气泡的 onModelSwitch 处理器：弹提示 + 在该失败气泡**正前方**插入一条「系统提示」
+   * 气泡（「『X』模型异常 → 已切换『Y』继续」），同时把失败气泡里「已累计的半截内容」清空
+   * （随后新模型的流式增量会重新填进同一气泡）并标为「模型切换中…」。
+   *
+   * 顺序很关键：系统提示插在失败气泡之前 → 用户**先**看到「已切换其他模型」、**再**看到新
+   * 模型重答的过程（旧实现把提示气泡追加到列表末尾，反而排在新模型答案之后，顺序颠倒）。
+   * 插「之前」而非「移到末尾」也保住并行批次里各席位气泡的相对次序。
+   */
+  const makeModelSwitchHandler = useCallback(
+    (bubbleId: number, isParallel: boolean) => (info: ModelSwitchInfo) => {
+      const who = info.agentName || "智能体";
+      triggerToast(`⚠️「${info.failedModel}」模型${info.reason}，已自动切换「${info.nextModel}」继续`);
+      if (isParallel) parallelStreamRef.current.delete(bubbleId);
+      const systemBubble: Step2Dialogue = {
+        id: Date.now() + Math.random(),
+        sender: "系统提示",
+        avatarType: "amber",
+        content: `⚠️ 模型容错：「${who}」所用模型「${info.failedModel}」${info.reason}，已自动切换到「${info.nextModel}」继续。`,
+        time: nowTime(),
+        confidence: "模型容错",
+      };
+      setStep2RoundtableDialogues((prev) => {
+        const idx = prev.findIndex((d) => d.id === bubbleId);
+        // 失败气泡找不到（异常兜底）：仍按旧行为在末尾追加系统提示。
+        if (idx < 0) return [...prev, systemBubble];
+        const cleared = { ...prev[idx], content: "", confidence: "模型切换中…" };
+        const next = [...prev];
+        next.splice(idx, 1, systemBubble, cleared);
+        return next;
+      });
+    },
+    [triggerToast],
+  );
+
   // ─── §6 并行流式：全接收 / 惰性渲染 / 节流 ───────────────────────────────
   /**
    * 节流 flush（~80ms 一拍，约 12fps）：**仅被选中**的席位把 ref 累积的全文挂到
@@ -1573,7 +1651,8 @@ export function useStep2Orchestration(
         "③ 风险 / 注意事项（如有）；④ 与其它席位的依赖 / 承接关系（如有）。";
       // 优化4：跨轮累积各席位**完整交付**，作为 peerDeliveries 传给后续席位的 run
       // （后端注入 context，席位用 read_peer_delivery 按需取全文，不进 prompt 不耗 token）。
-      const priorDeliveries: Array<{ name: string; content: string }> = [];
+      // 研讨前并行取数（gatherFirst）的产物作为初始 peerDeliveries 注入：研讨席位开局即带共享资料。
+      const priorDeliveries: Array<{ name: string; content: string }> = [...gatheredDeliveriesRef.current];
 
       // 共享的「单席位交付执行」——串行/并行分支共用。含**失败自动重试一次**（优化5，
       // 对齐 Step3 自愈：网络错误 / 502 重试，abort 不重试）。返回交付正文（aborted → 空）。
@@ -1601,8 +1680,13 @@ export function useStep2Orchestration(
               peerDeliveries: priorDeliveries,
               model: perSeatModel || selectedModelRef.current || undefined,
               // 席位执行模式（快速/思考/专业问答/多智能体问答）→ thinking/reasoning/subagent。
-              ...seatModeToRequestFields(selectedModeRef.current),
+              // 席位覆盖优先（业务链条里给该席位单独配的推理深度），否则跟随链条级 selectedMode。
+              ...seatModeToRequestFields(seatModesRef.current[a.agentId] ?? selectedModeRef.current),
+              // 会商技能识别强化（该席位在所选业务链条里的开关，按 agentId 查表）；与该席位
+              // agent 自身开关取 OR。
+              seatSkillDirective: seatSkillDirectivesRef.current[a.agentId] ?? false,
               signal: subAborter.signal,
+              onModelSwitch: makeModelSwitchHandler(a.bubbleId, a.isParallel),
               onTextDelta: (text) =>
                 a.isParallel ? ingestParallelDelta(a.bubbleId, text) : appendToDialogue(a.bubbleId, text),
               onPhaseChange: (phase, toolName, args) => {
@@ -1683,10 +1767,16 @@ export function useStep2Orchestration(
               // 第 2 轮起(已有席位交付)才是「综合轮」:让后端注入各席位完整交付供总控收口。
               // 首轮纯派活、无交付,传 false 保持上下文精简。
               synthesisMode: safetyCounter > 1,
+              // 削减重复广播(2026-06-20):首轮(safetyCounter==1)保留预广播——它把任务背景播进各席位
+              // thread,为席位打底;第 2 轮起的续轮/综合广播是「总控收到:<续轮 prompt>」纯噪声 + N 次
+              // 读写巨大席位 thread 的纯浪费(还会让弱模型从历史模仿派活),故 suppress。席位的前序交付
+              // 另经「席位交付广播」(broadcastSeatDeliveryToOthers)送达,不受影响。
+              suppressPreBroadcast: safetyCounter > 1,
               // 用户随干预上传的参考文件(consume-once:仅首轮 leader 带,之后清空)。
               files: takeOnce(pendingInjectFilesRef),
               model: selectedModelRef.current || undefined,
               signal: leaderAborter.signal,
+              onModelSwitch: makeModelSwitchHandler(leaderBubbleId, false),
               onTextDelta: (text) => appendToDialogue(leaderBubbleId, text),
               onPhaseChange: (phase, toolName, args) => {
                 const label = phaseLabel(phase, "leader", toolName);
@@ -1954,10 +2044,15 @@ export function useStep2Orchestration(
               dAgentThreadId: ids,
               agentName: coord,
               newMessage: leaderTask,
+              // 削减重复广播(2026-06-20):首个席位(i===0)保留预广播为其打底任务背景;从第 2 个席位起
+              // suppress——后续席位的前序交付已由「席位交付广播」送达其 thread,总控派活 prompt 再播一遍
+              // 是 N 次读写巨大 thread 的纯浪费(还会让弱模型模仿派活)。
+              suppressPreBroadcast: i > 0,
               // 用户随干预上传的参考文件(consume-once:仅首轮 leader 带,之后清空)。
               files: takeOnce(pendingInjectFilesRef),
               model: selectedModelRef.current || undefined,
               signal: leaderAborter.signal,
+              onModelSwitch: makeModelSwitchHandler(leaderBubbleId, false),
               onTextDelta: (text) => appendToDialogue(leaderBubbleId, text),
               onPhaseChange: (phase, toolName, args) => {
                 const label = phaseLabel(phase, "leader", toolName);
@@ -2028,10 +2123,18 @@ export function useStep2Orchestration(
               agentName: seat.agent_id,
               displayName: seatName,
               newMessage: task,
+              // 研讨前并行取数（gatherFirst）的产物作为共享资料注入：chain 席位也能直接引用、少重复检索。
+              // chain 串行靠 thread 广播看前序交付；取数资料这里另经 peerDeliveries 一并带上。
+              peerDeliveries: gatheredDeliveriesRef.current,
               model: perSeatModel || selectedModelRef.current || undefined,
               // 席位执行模式 → thinking/reasoning/subagent（与推荐/DAG 路径一致）。
-              ...seatModeToRequestFields(selectedModeRef.current),
+              // 席位覆盖优先（业务链条里给该席位单独配的推理深度），否则跟随链条级 selectedMode。
+              ...seatModeToRequestFields(seatModesRef.current[seat.agent_id] ?? selectedModeRef.current),
+              // 会商技能识别强化（该席位在所选业务链条里的开关，按 agentId 查表）；与该席位
+              // agent 自身开关取 OR。
+              seatSkillDirective: seatSkillDirectivesRef.current[seat.agent_id] ?? false,
               signal: subAborter.signal,
+              onModelSwitch: makeModelSwitchHandler(subBubbleId, false),
               onTextDelta: (text) => appendToDialogue(subBubbleId, text),
               onPhaseChange: (phase, toolName, args) => {
                 const label = phaseLabel(phase, "special", toolName);
@@ -2091,8 +2194,11 @@ export function useStep2Orchestration(
                 "各链条席位已按顺序完成发言,请你综合所有席位的交付,输出最终方案与结论。不要再派活、不要再向任何席位分配任务。",
               // 链条收口就是综合轮:让后端注入各席位完整交付正文。
               synthesisMode: true,
+              // 削减重复广播:收口轮不派活、研讨已结束,把总控收口 prompt 播进席位 thread 纯浪费,suppress。
+              suppressPreBroadcast: true,
               model: selectedModelRef.current || undefined,
               signal: closeoutAborter.signal,
+              onModelSwitch: makeModelSwitchHandler(closeoutBubbleId, false),
               onTextDelta: (text) => appendToDialogue(closeoutBubbleId, text),
               onPhaseChange: (phase, toolName, args) => {
                 const label = phaseLabel(phase, "leader", toolName);
@@ -2189,7 +2295,8 @@ export function useStep2Orchestration(
       let finishedAllStages = true;
       // 跨 stage 累积的**完整交付** {name, content}[] —— 注入下一 stage 席位的 run context
       // (peerDeliveries),供 read_peer_delivery 工具按需取全文(§12.9 传摘要按需传全文)。
-      const priorDeliveries: Array<{ name: string; content: string }> = [];
+      // 研讨前并行取数（gatherFirst）的产物作为初始注入：首个 stage 席位开局即带共享资料。
+      const priorDeliveries: Array<{ name: string; content: string }> = [...gatheredDeliveriesRef.current];
 
       // Phase 7：初始化 DAG 流程图节点状态 —— 计划内所有席位置 pending,执行过程中逐个点亮。
       const markDagNode = (agentId: string, state: ChainNodeState) =>
@@ -2253,6 +2360,7 @@ export function useStep2Orchestration(
               files: takeOnce(pendingInjectFilesRef),
               model: selectedModelRef.current || undefined,
               signal: leaderAborter.signal,
+              onModelSwitch: makeModelSwitchHandler(leaderBubbleId, false),
               onTextDelta: (text) => appendToDialogue(leaderBubbleId, text),
               onPhaseChange: (phase, toolName, args) => {
                 const label = phaseLabel(phase, "leader", toolName);
@@ -2370,10 +2478,15 @@ export function useStep2Orchestration(
                   peerDeliveries: priorDeliveries,
                   model: perSeatModel || selectedModelRef.current || undefined,
                   // 席位执行模式 → thinking/reasoning/subagent（与推荐/链条路径一致）。
-                  ...seatModeToRequestFields(selectedModeRef.current),
+                  // 席位覆盖优先（业务链条里给该席位单独配的推理深度），否则跟随链条级 selectedMode。
+                  ...seatModeToRequestFields(seatModesRef.current[agentId] ?? selectedModeRef.current),
+                  // 会商技能识别强化（该席位在所选业务链条里的开关，按 agentId 查表）；与该
+                  // 席位 agent 自身开关取 OR。
+                  seatSkillDirective: seatSkillDirectivesRef.current[agentId] ?? false,
                   signal: subAborter.signal,
                   // §6：并行席位走 ref 全量累积 + 节流 flush(只渲染选中的);单节点
                   // stage 实际串行,1 路流直接 setState 不卡,沿用 appendToDialogue。
+                  onModelSwitch: makeModelSwitchHandler(bubbleId, isParallel),
                   onTextDelta: (text) =>
                     isParallel ? ingestParallelDelta(bubbleId, text) : appendToDialogue(bubbleId, text),
                   onPhaseChange: (phase, toolName, args) => {
@@ -2495,10 +2608,132 @@ export function useStep2Orchestration(
     ],
   );
 
+  // 研讨前「并行取数」阶段：对**全席位并行**跑一轮「只取数、不研讨」，产出存进 gatheredDeliveriesRef
+  // 作为共享资料注入后续研讨轮（recommend/dag 经 priorDeliveries、chain 经 peerDeliveries）。复用
+  // recommend 同款并行批显示。每轮研讨只取一次（由 runActiveOrchestration 的 gatherPhaseDoneRef 闸门控制）。
+  const runGatherPhase = useCallback(
+    async (ids: ThreadIdMap): Promise<void> => {
+      const agents = selectedAgentsRef.current;
+      if (agents.length === 0) return;
+      // 与后端 engine._GATHER_TASK 同义：只取数、不研讨、不下结论。
+      const GATHER_TASK =
+        "【资料收集阶段——只取数、不研讨】\n现在是正式研讨**之前**的并行资料收集阶段。请你**只负责把与本次任务、" +
+        "与你这个席位职责相关的真实信息/数据收集、整理出来**（优先用你配置的技能去检索/获取真实信息，没有技能可凭专业知识梳理），" +
+        "为后续正式研讨打底。\n**这一步不要做分析评估、不要给方案、不要下结论**——把判断与方案留到研讨阶段。" +
+        "请把你收集到的关键信息整理成条理清晰的事实/要点清单输出，**不要向用户提问或等待确认**。";
+      const seatPrep = agents.map((a) => {
+        const meta = agentNameToRoleRef.current[a.agent_id.toLowerCase()];
+        const seatName = meta?.displayName ?? a.name;
+        const avatarType = meta?.avatarType ?? "blue";
+        const seatThreadId = resolveSeatThreadId(ids, a.agent_id);
+        const bubbleId = appendStreamingDialogue({
+          sender: seatName,
+          avatarType,
+          initialContent: "",
+          confidence: "并行取数中",
+          agentThreadId: seatThreadId,
+        });
+        return { agentId: a.agent_id, seatName, avatarType, seatThreadId, bubbleId, meta };
+      });
+      markParallelSpeakers(
+        seatPrep.map((p) => p.meta?.speakerId).filter((v): v is number => typeof v === "number"),
+      );
+      setParallelBatch(
+        seatPrep.map((p) => ({
+          agentId: p.agentId,
+          displayName: p.seatName,
+          avatarType: p.avatarType,
+          status: "running" as const,
+          bubbleId: p.bubbleId,
+        })),
+      );
+      setSelectedParallelSeats(seatPrep.slice(0, 1).map((p) => p.agentId));
+      const markBatchStatus = (agentId: string, status: ParallelSeatView["status"]) =>
+        setParallelBatch((prev) => prev.map((p) => (p.agentId === agentId ? { ...p, status } : p)));
+
+      const results = await Promise.all(
+        seatPrep.map(async ({ agentId, seatName, seatThreadId, bubbleId, meta }) => {
+          const perSeatModel = meta ? agentConfigsRef.current[meta.speakerId]?.model : undefined;
+          const subAborter = new AbortController();
+          activeAbortersRef.current.add(subAborter);
+          try {
+            const specRes = await streamMultiAgent({
+              agentType: "special",
+              dAgentThreadId: ids,
+              agentName: agentId,
+              displayName: seatName,
+              newMessage: GATHER_TASK,
+              model: perSeatModel || selectedModelRef.current || undefined,
+              ...seatModeToRequestFields(seatModesRef.current[agentId] ?? selectedModeRef.current),
+              seatSkillDirective: seatSkillDirectivesRef.current[agentId] ?? false,
+              signal: subAborter.signal,
+              onModelSwitch: makeModelSwitchHandler(bubbleId, true),
+              onTextDelta: (text) => ingestParallelDelta(bubbleId, text),
+              onPhaseChange: (phase, toolName, args) => {
+                const label = phaseLabel(phase, "special", toolName);
+                setDialogueConfidence(bubbleId, label);
+                appendStepIfNew(bubbleId, label, `${phase}:${toolName ?? ""}`, args);
+                handleArtifactToolPhase(phase, toolName, args, seatThreadId);
+              },
+              onUpstreamFrame: (frame) => {
+                handleUpstreamFrame(frame, seatThreadId);
+                ingestSubagentTaskFrame(frame, bubbleId);
+              },
+            });
+            activeAbortersRef.current.delete(subAborter);
+            finalizeDialogue(bubbleId, specRes.content, "资料收集");
+            markBatchStatus(agentId, "done");
+            if (meta) markSpeakerIdle(meta.speakerId);
+            parallelStreamRef.current.delete(bubbleId);
+            return specRes.content?.trim() ? { name: seatName, content: specRes.content } : null;
+          } catch (err) {
+            activeAbortersRef.current.delete(subAborter);
+            // 取数失败不阻断研讨：该席位无资料即可，研讨阶段它仍可自行检索。
+            finalizeDialogue(bubbleId, `(取数失败) ${(err as Error).message}`, "取数失败");
+            markBatchStatus(agentId, "done");
+            parallelStreamRef.current.delete(bubbleId);
+            return null;
+          }
+        }),
+      );
+
+      setParallelBatch([]);
+      setSelectedParallelSeats([]);
+      resetParallelStreams();
+      gatheredDeliveriesRef.current = results.filter(
+        (r): r is { name: string; content: string } => !!r,
+      );
+    },
+    [
+      appendStreamingDialogue,
+      finalizeDialogue,
+      ingestParallelDelta,
+      resetParallelStreams,
+      markParallelSpeakers,
+      markSpeakerIdle,
+      resolveSeatThreadId,
+      handleArtifactToolPhase,
+      handleUpstreamFrame,
+      ingestSubagentTaskFrame,
+      setDialogueConfidence,
+      appendStepIfNew,
+    ],
+  );
+
   // 按当前模式分发到对应编排函数。init / 恢复 / 干预 / 澄清回复统一走这里。
   const runActiveOrchestration = useCallback(
-    (seedMessage: string, ids: ThreadIdMap, coord: string) => {
+    async (seedMessage: string, ids: ThreadIdMap, coord: string) => {
       const mode = orchestrationModeRef.current;
+      // 研讨前并行取数（opt-in，每轮一次）：先把取数产物准备好，再分发到具体编排（研讨轮注入资料）。
+      // gatherPhaseDoneRef 闸门保证澄清续跑 / 干预重入不重复取数；置位在 await 前，避免并发重入双跑。
+      if (gatherFirstRef.current && !gatherPhaseDoneRef.current) {
+        gatherPhaseDoneRef.current = true;
+        try {
+          await runGatherPhase(ids);
+        } catch (err) {
+          console.warn("[roundtable] 研讨前并行取数阶段失败，跳过取数继续研讨:", err);
+        }
+      }
       // dag:**只在计划尚未跑过时**执行整张 DAG;一旦跑过(用户干预 / 恢复 / 澄清回复),
       // 改走 leader 自由派活循环,由总控接着派活,而不是把 DAG 从头重跑一遍。
       if (
@@ -2513,7 +2748,7 @@ export function useStep2Orchestration(
       }
       return runOrchestration(seedMessage, ids, coord);
     },
-    [runOrchestration, runChainOrchestration, runDagOrchestration],
+    [runGatherPhase, runOrchestration, runChainOrchestration, runDagOrchestration],
   );
 
   // ─── Effects ─────────────────────────────────────────────────────
@@ -2829,6 +3064,9 @@ export function useStep2Orchestration(
     step2InitRef.current = false;
     // 新一轮研讨:允许 DAG 计划重新执行一遍。
     dagPlanExecutedRef.current = false;
+    // 新一轮研讨:允许「研讨前并行取数」再取一次（清掉上一轮取数产物 + 闸门）。
+    gatherPhaseDoneRef.current = false;
+    gatheredDeliveriesRef.current = [];
     setInitNonce((n) => n + 1);
   }, []);
 
@@ -2858,7 +3096,22 @@ export function useStep2Orchestration(
       // 需要 ref 立刻可读到作业的真实线程,否则读到旧值导致接管失败。
       threadIdsRef.current = snapshot.threadIds;
       coordinatorNameRef.current = snapshot.coordinatorName;
-      setStep2RoundtableDialogues(snapshot.step2RoundtableDialogues);
+      // 历史快照是**静止记录**：任何残留「流式/加载中」的气泡（用户中途点了「停止」，
+      // 或草稿在流式期间被自动保存）都强制收尾为静止态。否则用户点聊天记录回看时，这些
+      // 气泡仍显示「调度中 / 等待响应 / 正在输出…」+ 加载光标，让人误以为还在进行（其实早已结束）。
+      // streaming===true 与「加载中」文案一一对应（finalizeDialogue 收尾时必置 false），故据此即可精确识别。
+      setStep2RoundtableDialogues(
+        snapshot.step2RoundtableDialogues.map((d) => {
+          if (!d.streaming) return d;
+          const hasText = (d.content ?? "").trim().length > 0;
+          return {
+            ...d,
+            streaming: false,
+            content: hasText ? d.content : "(已结束)",
+            confidence: "已结束",
+          };
+        }),
+      );
       setLastLeaderContent(snapshot.lastLeaderContent);
       setHasConsensus(snapshot.hasConsensus);
       setConsensusPercentage(snapshot.consensusPercentage);
@@ -2947,6 +3200,8 @@ export function useStep2Orchestration(
     hasAutoOpenedRef.current = new Set();
     pendingInjectPromptRef.current = null;
     dagPlanExecutedRef.current = false;
+    gatherPhaseDoneRef.current = false;
+    gatheredDeliveriesRef.current = [];
     deselectArtifact();
     step2InitRef.current = false;
   }, [abortAllInFlight, deselectArtifact, setArtifacts, resetParallelStreams]);

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

@@ -15,7 +15,7 @@ import { useCallback, useEffect, useRef, useState } from "react";
 import { useArtifacts } from "@/components/workspace/artifacts";
 import type { DraftStep3Snapshot } from "@/roundtable-planning/api/drafts";
 import {
-  initReportThread,
+  initDashboardThread,
   streamMultiAgent,
   type StreamPhase,
 } from "@/roundtable-planning/api/multi-agent";
@@ -35,7 +35,7 @@ import {
 } from "@/roundtable-planning/lib/report-template";
 import { nowTime } from "@/roundtable-planning/lib/roundtable-constants";
 
-const DASH_AGENT_FALLBACK = "roundtable-report";
+const DASH_AGENT_FALLBACK = "roundtable-dashboard";
 
 export type DashboardPhase = "idle" | "creating" | "streaming" | "done" | "error";
 
@@ -48,6 +48,17 @@ interface UseStep3DashboardOptions {
   themeMode: "light" | "dark";
   savedReport?: DraftStep3Snapshot | null;
   onReportSaved?: (snapshot: DraftStep3Snapshot) => void;
+  /**
+   * 自定义初始 prompt 构造（独立大屏页用：输入是任务原始 JSON，让智能体分析转换）。
+   * 返回空/未提供时回退默认的 buildDashboardPrompt（圆桌研讨成果模式）。
+   */
+  buildInitialPrompt?: () => string | null | undefined;
+}
+
+/** 恢复大屏时可带上的历史生成过程对话（文字 + 步骤条）+ stub —— 整段回显用。 */
+export interface Step3DashRestore {
+  dialogues?: unknown[];
+  seatStubMessages?: Record<string, unknown[]>;
 }
 
 export interface UseStep3DashboardReturn {
@@ -69,10 +80,15 @@ export interface UseStep3DashboardReturn {
   abort: () => void;
   /** 本流是否允许**自动**打开沙箱预览（视图挂载=true / 卸载=false；并行流防抢沙箱）。 */
   setPreviewEnabled: (enabled: boolean) => void;
-  /** 从草稿恢复（带 marker 的大屏 HTML，旧版存稿）：种 stub + 完成气泡，不自动开沙箱。 */
-  hydrateSaved: (html: string) => void;
+  /**
+   * 从草稿恢复（带 marker 的大屏 HTML，旧版存稿）：种 stub + 气泡，不自动开沙箱。
+   * `saved` 带历史完整对话(文字 + 步骤条) + stub 时整段回显，否则重建单条「历史记录」气泡。
+   */
+  hydrateSaved: (html: string, saved?: Step3DashRestore) => void;
   /** 从草稿/后台作业恢复（dashboardJson 结构化数据）：按**当前主题**渲染后展示。 */
-  hydrateFromJson: (jsonStr: string) => void;
+  hydrateFromJson: (jsonStr: string, saved?: Step3DashRestore) => void;
+  /** 从持久化恢复**真实聊天记录** + 结构化数据（独立大屏页按 taskId 取回时用）。 */
+  hydrateTranscript: (dialogues: Step2Dialogue[], dashboardJson: string | null) => void;
   /** 手动打开大屏沙箱预览（恢复后/用户点气泡）。 */
   openDashboardPreview: () => void;
 }
@@ -105,6 +121,7 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
     themeMode,
     savedReport,
     onReportSaved,
+    buildInitialPrompt,
   } = options;
 
   const onSavedRef = useRef(onReportSaved);
@@ -112,6 +129,11 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
     onSavedRef.current = onReportSaved;
   }, [onReportSaved]);
 
+  const buildInitialPromptRef = useRef(buildInitialPrompt);
+  useEffect(() => {
+    buildInitialPromptRef.current = buildInitialPrompt;
+  }, [buildInitialPrompt]);
+
   const { select: selectArtifact, setOpen: setArtifactsOpen, open: artifactsOpen } = useArtifacts();
   const artifactsOpenRef = useRef(artifactsOpen);
   useEffect(() => {
@@ -269,7 +291,7 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
       const { bubbleId, message, aborter } = args;
       let threadId = liveThreadRef.current;
       if (!threadId) {
-        const init = await initReportThread({ signal: aborter.signal });
+        const init = await initDashboardThread({ signal: aborter.signal });
         if (aborter.signal.aborted) return;
         threadId = init.threadId;
         agentNameRef.current = init.agentName || DASH_AGENT_FALLBACK;
@@ -303,6 +325,12 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
         newMessage: message,
         model: selectedModel || undefined,
         signal: aborter.signal,
+        // 模型自动容错：后端切到下一个模型重跑 → 清空失败尝试的半截累计（acc + 气泡）。
+        onModelSwitch: (info) => {
+          acc = "";
+          setDialogues((prev) => prev.map((d) => (d.id === bubbleId ? { ...d, content: "" } : d)));
+          setDialogueConfidence(bubbleId, `模型切换：${info.failedModel}→${info.nextModel}（${info.reason}）`);
+        },
         onTextDelta: (text) => {
           appendToDialogue(bubbleId, text);
           acc += text;
@@ -374,7 +402,13 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
       ]
         .filter(Boolean)
         .join("\n");
-      const prompt = buildDashboardPrompt({ intentText, seatDeliveries, consensusText });
+      // 独立大屏页：用自定义 prompt（输入任务原始 JSON，让智能体分析转换）；
+      // 否则回退默认的圆桌研讨成果 prompt。
+      const custom = buildInitialPromptRef.current?.();
+      const prompt =
+        custom && custom.trim()
+          ? custom
+          : buildDashboardPrompt({ intentText, seatDeliveries, consensusText });
       await streamOnce({ bubbleId, message: prompt, aborter });
     } catch (err) {
       if (aborter.signal.aborted) return;
@@ -434,7 +468,7 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
   );
 
   const hydrateSaved = useCallback(
-    (savedHtml: string) => {
+    (savedHtml: string, saved?: Step3DashRestore) => {
       abort();
       runningRef.current = false;
       htmlRef.current = savedHtml;
@@ -451,21 +485,39 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
       const { messageId, toolCallId } = upsertDashStub(synthThreadId, savedHtml);
       // 记录预览锚点（不打开）：进入大屏视图时若沙箱已开着，可立即接管显示本流产物。
       lastAutoOpenRef.current = { threadId: synthThreadId, messageId, toolCallId };
-      const bubbleId = Date.now() + Math.random();
-      setDialogues([
-        {
-          id: bubbleId,
-          sender: "大屏绘制智能体",
-          avatarType: "blue",
-          content:
-            "已从历史记录恢复上次生成的大屏。点击下方「打开大屏预览」查看，或输入修改要求重新生成。",
-          time: nowTime(),
-          confidence: "历史记录",
-          streaming: false,
-          steps: [],
-          agentThreadId: synthThreadId,
-        },
-      ]);
+      // 历史完整对话(文字 + 步骤条) + stub —— 新版草稿存了就整段回显，像第二步一样。
+      const savedDialogues = Array.isArray(saved?.dialogues)
+        ? (saved!.dialogues as Step2Dialogue[])
+        : [];
+      const savedStubs =
+        saved?.seatStubMessages && typeof saved.seatStubMessages === "object"
+          ? (saved.seatStubMessages as Record<string, StubAiMessage[]>)
+          : null;
+      if (savedStubs && Object.keys(savedStubs).length) {
+        // 合并历史 stub（各气泡步骤卡的真线程预览），保留合成 stub（恢复后大屏预览锚点）。
+        const merged = { ...stubRef.current, ...savedStubs };
+        stubRef.current = merged;
+        setSeatStubMessages(merged);
+      }
+      if (savedDialogues.length) {
+        setDialogues(savedDialogues);
+      } else {
+        const bubbleId = Date.now() + Math.random();
+        setDialogues([
+          {
+            id: bubbleId,
+            sender: "大屏绘制智能体",
+            avatarType: "blue",
+            content:
+              "已从历史记录恢复上次生成的大屏。点击下方「打开大屏预览」查看，或输入修改要求重新生成。",
+            time: nowTime(),
+            confidence: "历史记录",
+            streaming: false,
+            steps: [],
+            agentThreadId: synthThreadId,
+          },
+        ]);
+      }
       setError(null);
       setPhase("done");
       // 不自动开沙箱（对齐 06-12「进第三步默认关闭」策略），用户点按钮随时可开。
@@ -475,17 +527,49 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
 
   /** 从 dashboardJson（草稿/后台作业存的结构化数据）恢复：按当前主题渲染。 */
   const hydrateFromJson = useCallback(
-    (jsonStr: string) => {
+    (jsonStr: string, saved?: Step3DashRestore) => {
       const parsed = parseReportJson(jsonStr);
       if (!parsed) return;
       const rendered = renderDashboardHtml(parsed, { generatedAt: formatNow(), theme: themeMode });
-      hydrateSaved(rendered); // 先恢复 HTML 沙箱路径（内部会 setData(null) 清残留）
+      hydrateSaved(rendered, saved); // 先恢复 HTML 沙箱路径（内部会 setData(null) 清残留）+ 历史对话
       setData(parsed); // 再写回本草稿结构化数据 → 应用内 React 大屏直接渲染（批量更新，最终生效）
       dataRef.current = parsed; // 续轮修改的基线 → 从历史恢复后也能精准局部改
     },
     [themeMode, hydrateSaved],
   );
 
+  /** 从持久化恢复真实聊天记录 + 结构化数据（独立大屏页按 taskId 取回时用）。
+   *  与 hydrateFromJson 的区别：保留**用户真实的历史对话气泡**，而非造一条合成提示。 */
+  const hydrateTranscript = useCallback(
+    (savedDialogues: Step2Dialogue[], dashboardJson: string | null) => {
+      abort();
+      runningRef.current = false;
+      const synthThreadId = "roundtable-dashboard-restored";
+      liveThreadRef.current = null; // 合成线程非真线程：续问会新建线程重新生成
+      setDashThreadId(synthThreadId);
+      setActiveArtifactThreadId(synthThreadId);
+      const parsed = dashboardJson ? parseReportJson(dashboardJson) : null;
+      if (parsed) {
+        const rendered = renderDashboardHtml(parsed, { generatedAt: formatNow(), theme: themeMode });
+        htmlRef.current = rendered;
+        setHtml(rendered);
+        setData(parsed);
+        dataRef.current = parsed; // 续轮修改的基线
+        const { messageId, toolCallId } = upsertDashStub(synthThreadId, rendered);
+        lastAutoOpenRef.current = { threadId: synthThreadId, messageId, toolCallId };
+      } else {
+        htmlRef.current = null;
+        setHtml(null);
+        setData(null);
+        dataRef.current = null;
+      }
+      setDialogues(Array.isArray(savedDialogues) ? savedDialogues : []);
+      setError(null);
+      setPhase(parsed ? "done" : "idle");
+    },
+    [abort, themeMode, upsertDashStub],
+  );
+
   // 恢复路径辅助：savedReport 由组件/页面按字段调用对应 hydrate；这里只消除未用告警。
   void savedReport;
   void isDashboardHtml;
@@ -519,6 +603,7 @@ export function useStep3Dashboard(options: UseStep3DashboardOptions): UseStep3Da
     setPreviewEnabled,
     hydrateSaved,
     hydrateFromJson,
+    hydrateTranscript,
     openDashboardPreview,
   };
 }

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

@@ -770,6 +770,16 @@ export function useStep3Report(
             newMessage: prompt,
             model: selectedModel || undefined,
             signal: aborter.signal,
+            // 模型自动容错：后端切到下一个模型重跑 → 清空失败尝试半截正文 + 步骤卡留可见提示。
+            onModelSwitch: (info) => {
+              setDialogues((prev) => prev.map((d) => (d.id === bubbleId ? { ...d, content: "" } : d)));
+              setDialogueConfidence(bubbleId, `模型切换：${info.failedModel}→${info.nextModel}`);
+              appendStepIfNew(
+                bubbleId,
+                `⚠️ 模型容错：「${info.failedModel}」${info.reason}，改用「${info.nextModel}」`,
+                `model_switch:${info.nextModel}`,
+              );
+            },
             onTextDelta: (text) => appendToDialogue(bubbleId, text),
             onPhaseChange: (p, toolName, toolArgs) => {
               const label = reportPhaseLabel(p, toolName);
@@ -1034,7 +1044,17 @@ export function useStep3Report(
           },
         ],
       };
-      stubRef.current = stub;
+      // 历史完整对话(中间文字 + 步骤条) + stub —— 新版草稿存了就整段回显，像第二步一样。
+      const savedDialogues = Array.isArray(snap.reportDialogues)
+        ? (snap.reportDialogues as Step2Dialogue[])
+        : [];
+      const savedStubs =
+        snap.reportSeatStubMessages && typeof snap.reportSeatStubMessages === "object"
+          ? (snap.reportSeatStubMessages as Record<string, StubAiMessage[]>)
+          : null;
+      // 合并：合成 stub 保住「恢复后预览」锚点(synthThreadId)，历史 stub 保住各气泡步骤卡的真线程预览。
+      const effectiveStub = savedStubs ? { ...stub, ...savedStubs } : stub;
+      stubRef.current = effectiveStub;
       // 记录预览锚点（不打开）：进入本视图且沙箱已开着时可立即接管显示自家 HTML（防串台）。
       lastAutoOpenedUrlRef.current = buildWriteFileVirtualUrl(
         REPORT_OUTPUT_PATH,
@@ -1042,33 +1062,40 @@ export function useStep3Report(
         toolCallId,
       );
       lastAutoThreadRef.current = synthThreadId;
-      setSeatStubMessages(stub);
+      setSeatStubMessages(effectiveStub);
       setReportThreadId(synthThreadId);
       setActiveArtifactThreadId(synthThreadId);
 
-      const bubbleId = Date.now() + Math.random();
-      bubbleIdRef.current = bubbleId;
-      setDialogues([
-        {
-          id: bubbleId,
-          sender: "方案总结智能体",
-          avatarType: "blue",
-          content: snap.summary?.trim() || "已从历史记录恢复上次生成的可视化研讨汇报。",
-          time: nowTime(),
-          confidence: "历史记录",
-          streaming: false,
-          steps: [
-            {
-              id: `${bubbleId}-0`,
-              key: "tool_calling:write_file",
-              label: "已绘制图表 HTML",
-              ts: nowTime(),
-              args: { path: REPORT_OUTPUT_PATH },
-            },
-          ],
-          agentThreadId: synthThreadId,
-        },
-      ]);
+      if (savedDialogues.length) {
+        // 整段回显历史绘制过程（每条气泡的文字内容 + 步骤条都在），与第二步一致。
+        bubbleIdRef.current = savedDialogues[savedDialogues.length - 1]?.id ?? null;
+        setDialogues(savedDialogues);
+      } else {
+        // 旧草稿没存对话 → 回退重建单条「历史记录」气泡（仅最终产物）。
+        const bubbleId = Date.now() + Math.random();
+        bubbleIdRef.current = bubbleId;
+        setDialogues([
+          {
+            id: bubbleId,
+            sender: "方案总结智能体",
+            avatarType: "blue",
+            content: snap.summary?.trim() || "已从历史记录恢复上次生成的可视化研讨汇报。",
+            time: nowTime(),
+            confidence: "历史记录",
+            streaming: false,
+            steps: [
+              {
+                id: `${bubbleId}-0`,
+                key: "tool_calling:write_file",
+                label: "已绘制图表 HTML",
+                ts: nowTime(),
+                args: { path: REPORT_OUTPUT_PATH },
+              },
+            ],
+            agentThreadId: synthThreadId,
+          },
+        ]);
+      }
       setError(null);
       setPhase("done");
       // 不再自动打开沙箱预览（2026-06-12）：进入第三步默认关闭沙箱，只有开始

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

@@ -22,6 +22,29 @@ export interface ChainSeat {
   name: string;
   /** 描述快照，同样作为实时数据的回退。 */
   description?: string;
+  /**
+   * 可选「席位模型覆盖」：该席位作为子智能体执行时用的 LLM model name（须是后端
+   * `config.yaml` `models[]` 里的一个 `name`）。空 / 缺省 = 不覆盖，运行时回退到全局
+   * 所选模型。选入研讨时灌进 `agentConfigs[speakerId].model`（见 `RoundtablePlanningPage`
+   * 的 `handleConfirmAgents`）→ 走现有 per-seat 模型链路。
+   */
+  model?: string | null;
+  /**
+   * 可选「会商技能识别强化」开关（弱模型补偿）。true = 该席位作为会商子智能体执行时，把其
+   * 配置的技能（名称 + SKILL.md 路径 + 必须先 read_file 的硬指令）拼进本轮任务。与该席位
+   * 智能体自身的同名开关（智能体编辑里的开关）取 OR。缺省 / false = 关。随 `seats` JSON 落库
+   * （无需 DB 列），在链条编辑器里逐席位开关。
+   */
+  seat_skill_directive?: boolean;
+  /**
+   * 可选「席位推理深度覆盖」：覆盖链条级 `seatMode`，只对该席位生效。值是同一套
+   * `SeatMode`（flash/thinking/pro/ultra）；null / 缺省 = 跟随链条级默认。用于「卡顿提速」：
+   * 把信息收集/边角席位单独降到 `flash`（不思考、最快），只给关键席位留 `pro`/`ultra`。
+   * 随 `seats` JSON 落库（无需 DB 列，但需在后端 `ChainSeatSchema` 显式声明，否则 model_dump
+   * 会剥掉）。**字段名用 snake_case `seat_mode`** 与 `model`/`seat_skill_directive` 一致（seats
+   * 数组在 `api/chains.ts` 不做 camel↔snake 转换，键名须与后端 schema 逐字匹配）。
+   */
+  seat_mode?: SeatMode | null;
 }
 
 /** 一条可复用的业务链条（与后端 `/api/roundtable-chains` 记录对应）。 */
@@ -54,6 +77,12 @@ export interface BusinessChain {
    * 缺省 = 未设，调用方回退 `DEFAULT_SEAT_MODE`(pro)。
    */
   seatMode?: SeatMode;
+  /**
+   * 可选「研讨前并行取数」开关（逐条 opt-in，缺省 false）。true = 选入研讨时，研讨前先跑一轮
+   * **全席位并行『取数』**（各席位只调技能取数、不研讨），产出作为共享资料注入后续研讨轮，把最慢
+   * 的技能延迟前置并行、给（尤其 chain 串行的）研讨段提速。三种编排通用。后端列 `gather_first`。
+   */
+  gatherFirst?: boolean;
   /** 是否已发布为公共（所有账号可在「公共」筛选查看 / 选入研讨）。 */
   isPublic?: boolean;
   /** 是否当前用户所有（仅本人可编辑 / 删除 / 发布；公共筛选里别人的链条为 false）。 */
@@ -70,8 +99,12 @@ export interface BusinessChain {
  * `agents` + 一个 `mode`。
  */
 export interface SeatSelectionResult {
-  /** 有序席位 —— 与现有 `handleConfirmAgents` 入参兼容。dag 模式下按 stage 展平排序。 */
-  agents: Array<{ agent_id: string; name: string }>;
+  /**
+   * 有序席位 —— 与现有 `handleConfirmAgents` 入参兼容。dag 模式下按 stage 展平排序。
+   * `model` 为该席位在来源链条里配置的模型覆盖（空 / 缺省 = 跟随全局模型）。
+   * `seat_skill_directive` 为该席位在来源链条里配置的「技能识别强化」开关（缺省 = 关）。
+   */
+  agents: Array<{ agent_id: string; name: string; model?: string | null; seat_skill_directive?: boolean; seatMode?: SeatMode | null }>;
   /**
    * 决定 Step 2 走哪种编排：
    *  - `recommend` 总控自由派活；
@@ -97,6 +130,11 @@ export interface SeatSelectionResult {
    * 缺省由调用方按 `DEFAULT_SEAT_MODE`（pro）处理。
    */
   seatMode?: SeatMode;
+  /**
+   * 「研讨前并行取数」开关（来源链条的 `gatherFirst`）。true = 研讨前先并行取数再研讨。
+   * 三种编排通用，缺省 false。recommend（无链条）= false。
+   */
+  gatherFirst?: boolean;
 }
 
 /** 链条席位数硬约束，与圆桌推荐弹窗的 `MIN_SELECTED`/`MAX_SELECTED` 对齐。 */
@@ -122,6 +160,16 @@ export function buildChainSeatSelection(
   const nameById = new Map(candidates.map((c) => [c.agent_id, c.name]));
   const seatNameById = new Map(chain.seats.map((s) => [s.agent_id, s.name]));
   const nameOf = (id: string) => nameById.get(id) ?? seatNameById.get(id) ?? id;
+  // 席位模型覆盖（链条配置）：按 agent_id 取，空/缺省 = 跟随全局。
+  const modelById = new Map(chain.seats.map((s) => [s.agent_id, s.model ?? null]));
+  const modelOf = (id: string) => modelById.get(id) ?? null;
+  // 席位「技能识别强化」开关（链条配置）：按 agent_id 取，缺省 = 关。
+  const skillById = new Map(chain.seats.map((s) => [s.agent_id, s.seat_skill_directive ?? false]));
+  const skillOf = (id: string) => skillById.get(id) ?? false;
+  // 席位「推理深度覆盖」（链条配置 seat_mode）：按 agent_id 取，null/缺省 = 跟随链条级 seatMode。
+  // 输出到 SeatSelectionResult.agents[].seatMode（camel，喂给编排/作业的 seatModes map）。
+  const seatModeById = new Map(chain.seats.map((s) => [s.agent_id, s.seat_mode ?? null]));
+  const seatModeOf = (id: string) => seatModeById.get(id) ?? null;
 
   const survivingSeats = chain.seats.filter((s) => existingIds.has(s.agent_id));
   if (survivingSeats.length < CHAIN_MIN_SEATS) return null;
@@ -143,13 +191,13 @@ export function buildChainSeatSelection(
     if (hasParallel || hasGoal || hasCoord) {
       const agents = plan.stages
         .flatMap((st) => st.agentIds)
-        .map((id) => ({ agent_id: id, name: nameOf(id) }));
-      return { agents, mode: "dag", chain: chainMeta, plan, dagExecMode: "fast", seatMode: chain.seatMode };
+        .map((id) => ({ agent_id: id, name: nameOf(id), model: modelOf(id), seat_skill_directive: skillOf(id), seatMode: seatModeOf(id) }));
+      return { agents, mode: "dag", chain: chainMeta, plan, dagExecMode: "fast", seatMode: chain.seatMode, gatherFirst: chain.gatherFirst ?? false };
     }
   }
 
-  const agents = survivingSeats.map((s) => ({ agent_id: s.agent_id, name: nameOf(s.agent_id) }));
-  return { agents, mode: "chain", chain: chainMeta, seatMode: chain.seatMode };
+  const agents = survivingSeats.map((s) => ({ agent_id: s.agent_id, name: nameOf(s.agent_id), model: modelOf(s.agent_id), seat_skill_directive: skillOf(s.agent_id), seatMode: seatModeOf(s.agent_id) }));
+  return { agents, mode: "chain", chain: chainMeta, seatMode: chain.seatMode, gatherFirst: chain.gatherFirst ?? false };
 }
 
 /**

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

@@ -13,6 +13,7 @@
  * 对应需求文档 `docs/roundtable-dag-orchestration.md` §2（分层编辑器，竖列分组）。
  */
 import type { BusinessChain, ChainSeat } from "@/roundtable-planning/lib/business-chain";
+import type { SeatMode } from "@/roundtable-planning/lib/seat-mode";
 
 /** 一个并行 stage：含其并行席位与可选「本阶段目标」（注入给总控/席位，仅 dag 模式生效）。 */
 export interface StageGroup {
@@ -112,6 +113,49 @@ export function setStageGoal(groups: StageGroups, stageIdx: number, goal: string
   return groups.map((g, i) => (i === stageIdx ? { ...g, goal } : g));
 }
 
+/**
+ * 设置某个席位的「模型覆盖」（不可变，供编辑器席位下拉 onChange）。
+ * `model` 为 null/"" 表示清除覆盖（跟随全局模型）。按 agent_id 定位，跨 stage 适用。
+ */
+export function setSeatModel(groups: StageGroups, agentId: string, model: string | null): StageGroups {
+  return groups.map((g) => {
+    if (!g.seats.some((s) => s.agent_id === agentId)) return g;
+    return {
+      ...g,
+      seats: g.seats.map((s) => (s.agent_id === agentId ? { ...s, model: model || null } : s)),
+    };
+  });
+}
+
+/**
+ * 设置某个席位的「会商技能识别强化」开关（不可变，供编辑器席位下拉 onChange）。
+ * 按 agent_id 定位，跨 stage 适用。随 `seats` JSON 落库。
+ */
+export function setSeatSkillDirective(groups: StageGroups, agentId: string, enabled: boolean): StageGroups {
+  return groups.map((g) => {
+    if (!g.seats.some((s) => s.agent_id === agentId)) return g;
+    return {
+      ...g,
+      seats: g.seats.map((s) => (s.agent_id === agentId ? { ...s, seat_skill_directive: enabled } : s)),
+    };
+  });
+}
+
+/**
+ * 设置某个席位的「推理深度覆盖」（不可变，供编辑器席位下拉 onChange）。
+ * `mode` 为 null = 清除覆盖（跟随链条级 seatMode）。按 agent_id 定位，跨 stage 适用。
+ * 随 `seats` JSON 落库。
+ */
+export function setSeatMode(groups: StageGroups, agentId: string, mode: SeatMode | null): StageGroups {
+  return groups.map((g) => {
+    if (!g.seats.some((s) => s.agent_id === agentId)) return g;
+    return {
+      ...g,
+      seats: g.seats.map((s) => (s.agent_id === agentId ? { ...s, seat_mode: mode } : s)),
+    };
+  });
+}
+
 // ── 变换（均返回新结构，不可变）──────────────────────────────────────────────
 
 /** 末尾追加一个**新单席位 stage**（线性追加，pool 点击加入默认行为）。 */

frontend-web/src/roundtable-planning/lib/dag-types.ts

@@ -392,6 +392,13 @@ export function buildDagStageLeaderTask(args: {
     lines.push(
       `【本阶段目标】${goalText}`,
       "请据此目标为每个席位拆解任务，并要求他们**显式承接上一阶段的产出**来完成本阶段目标。",
+      "⚠️ 派活时**严格忠实于本阶段目标，不要自行新增目标里没有的「数量上限 / 只取最有代表性的 N 组 / 精简归纳成几条」等限制**，" +
+        "也不要照搬其它阶段的数量（如上一阶段筛了 3 组，不代表本阶段也只要 3 组）；" +
+        "目标没要求筛选 / 限定数量时，就要求席位**按其职责把每一条都完整输出**——" +
+        "若上一阶段有 N 条产出需逐条处理，就让席位**逐条、全部**产出（有多少条就出多少条），绝不替席位归纳 / 合并 / 只取代表性的几条。",
+      "⚠️ 也**不要替席位新增目标 / 席位职责之外的「输出体例 / 风格」要求**（如『写成连贯故事 / 要有场景感 / " +
+        "举具体城市景区为例 / 虚构时间地点情节』等）——派活只需转达本阶段目标 + 上一阶段产物 + 承接关系，" +
+        "**让席位严格按它自己的职责设定（SOUL）输出**，且**忠实基于上一阶段的真实产物做分析，不要诱导席位脱离输入去编造 / 虚构事例**。",
     );
   }
   lines.push(

frontend-web/src/roundtable-planning/lib/flow-graph.test.ts

@@ -9,10 +9,13 @@ import assert from "node:assert/strict";
 import test from "node:test";
 
 import {
+  applyNodeEdit,
+  deleteNodeFromGraph,
   detectFlowIntent,
   extractFlowGraph,
   hasFlowFence,
   layoutFlowGraph,
+  serializeFlowGraph,
   stripFlowFence,
 } from "./flow-graph";
 
@@ -206,3 +209,51 @@ test("layoutFlowGraph：环不死循环", () => {
   assert.equal(positioned.length, 2);
   positioned.forEach((n) => assert.ok(Number.isFinite(n.x) && Number.isFinite(n.y)));
 });
+
+test("serializeFlowGraph：与 extractFlowGraph 往返一致（含 group/detail/边标签）", () => {
+  const text = [
+    "```flow-json",
+    '{"title":"方案","nodes":[',
+    '{"id":"t","label":"任务X","type":"start","group":"任务","detail":"目标说明"},',
+    '{"id":"p1","label":"目的1","type":"task","group":"目的","detail":"名称+理由","from":["t"]},',
+    '{"id":"d","label":"判断","type":"decision","from":[{"id":"p1","label":"可行"}]}',
+    "]}",
+    "```",
+  ].join("\n");
+  const g = extractFlowGraph(text)!;
+  const round = extractFlowGraph(serializeFlowGraph(g))!;
+  assert.equal(round.title, "方案");
+  assert.deepEqual(
+    round.nodes.map((n) => [n.id, n.label, n.group, n.detail]),
+    g.nodes.map((n) => [n.id, n.label, n.group, n.detail]),
+  );
+  assert.deepEqual(round.edges, g.edges); // 含 {from:"p1",to:"d",label:"可行"}
+});
+
+test("applyNodeEdit：改 label/group/detail，其余节点不变", () => {
+  const g = extractFlowGraph(
+    '```flow-json\n{"nodes":[{"id":"a","label":"A","type":"task","group":"目的"},{"id":"b","label":"B","type":"role","group":"行为体","from":["a"]}]}\n```',
+  )!;
+  const next = applyNodeEdit(g, "a", { label: "新目的", group: "目标", detail: "改后的详情" });
+  const a = next.nodes.find((n) => n.id === "a")!;
+  assert.equal(a.label, "新目的");
+  assert.equal(a.group, "目标");
+  assert.equal(a.detail, "改后的详情");
+  // b 不变；边不变。
+  assert.equal(next.nodes.find((n) => n.id === "b")!.label, "B");
+  assert.deepEqual(next.edges, g.edges);
+  // 空 group/detail → 清空（置 undefined）。
+  const cleared = applyNodeEdit(g, "a", { group: "  ", detail: "" });
+  const a2 = cleared.nodes.find((n) => n.id === "a")!;
+  assert.equal(a2.group, undefined);
+});
+
+test("deleteNodeFromGraph：删节点同时删掉与它相连的所有边", () => {
+  const g = extractFlowGraph(
+    '```flow-json\n{"nodes":[{"id":"t","label":"任务"},{"id":"p","label":"目的","from":["t"]},{"id":"b","label":"行为体","from":["p"]}]}\n```',
+  )!;
+  const next = deleteNodeFromGraph(g, "p");
+  assert.deepEqual(next.nodes.map((n) => n.id), ["t", "b"]);
+  // t→p 和 p→b 两条边都没了（b 变孤点）。
+  assert.equal(next.edges.length, 0);
+});

frontend-web/src/roundtable-planning/lib/flow-graph.ts

@@ -53,11 +53,16 @@ export interface FlowGraphData {
   edges: FlowGraphEdge[];
 }
 
+export interface FlowNodeColors {
+  label: string;
+  bg: string;
+  border: string;
+  text: string;
+  dot: string;
+}
+
 /** 各类型节点的配色（浅底 + 深字 + 强调点），前端按 type 区分颜色。 */
-export const FLOW_NODE_TYPE_META: Record<
-  FlowNodeType,
-  { label: string; bg: string; border: string; text: string; dot: string }
-> = {
+export const FLOW_NODE_TYPE_META: Record<FlowNodeType, FlowNodeColors> = {
   start: { label: "开始", bg: "#f1f5f9", border: "#94a3b8", text: "#334155", dot: "#64748b" },
   end: { label: "结束", bg: "#f1f5f9", border: "#94a3b8", text: "#334155", dot: "#64748b" },
   stage: { label: "阶段", bg: "#eff6ff", border: "#60a5fa", text: "#1d4ed8", dot: "#3b82f6" },
@@ -68,6 +73,27 @@ export const FLOW_NODE_TYPE_META: Record<
   role: { label: "角色", bg: "#faf5ff", border: "#c084fc", text: "#7e22ce", dot: "#a855f7" },
 };
 
+/**
+ * 深蓝主题下的节点配色（对齐《深蓝色 UI 规范》ZS-004 深底）：保留各类型色相作识别，
+ * 底色取该色相在深底上的低透明度叠色（dot @ ~16–18%），描边取色相高透明度，
+ * 文字用同色相浅色调（深底可读），强调点沿用亮色。供流程图弹窗 + 头部小节点用。
+ */
+export const FLOW_NODE_TYPE_META_DARK: Record<FlowNodeType, FlowNodeColors> = {
+  start: { label: "开始", bg: "rgba(100,116,139,0.20)", border: "rgba(148,163,184,0.55)", text: "#C5CFE0", dot: "#94a3b8" },
+  end: { label: "结束", bg: "rgba(100,116,139,0.20)", border: "rgba(148,163,184,0.55)", text: "#C5CFE0", dot: "#94a3b8" },
+  stage: { label: "阶段", bg: "rgba(59,130,246,0.20)", border: "rgba(96,165,250,0.60)", text: "#bfdbfe", dot: "#60a5fa" },
+  task: { label: "任务", bg: "rgba(6,182,212,0.20)", border: "rgba(34,211,238,0.60)", text: "#a5f3fc", dot: "#22d3ee" },
+  decision: { label: "判断", bg: "rgba(245,158,11,0.18)", border: "rgba(251,191,36,0.55)", text: "#fcd34d", dot: "#fbbf24" },
+  risk: { label: "风险", bg: "rgba(239,68,68,0.18)", border: "rgba(248,113,113,0.55)", text: "#fecaca", dot: "#f87171" },
+  deliverable: { label: "交付物", bg: "rgba(34,197,94,0.18)", border: "rgba(74,222,128,0.55)", text: "#bbf7d0", dot: "#4ade80" },
+  role: { label: "角色", bg: "rgba(168,85,247,0.20)", border: "rgba(192,132,252,0.58)", text: "#e9d5ff", dot: "#c084fc" },
+};
+
+/** 按明暗取节点配色表。 */
+export function flowNodeMeta(dark: boolean): Record<FlowNodeType, FlowNodeColors> {
+  return dark ? FLOW_NODE_TYPE_META_DARK : FLOW_NODE_TYPE_META;
+}
+
 const VALID_TYPES = new Set<string>(Object.keys(FLOW_NODE_TYPE_META));
 
 export const FLOW_FENCE_OPEN = "```flow-json";
@@ -281,6 +307,64 @@ export function extractFlowGraph(text: string): FlowGraphData | null {
   return { title, nodes, edges: validEdges };
 }
 
+/**
+ * 把结构化图序列化回一个 ```flow-json 代码块（与 extractFlowGraph 互逆）。
+ * 用途：后端校验后拿到 FlowGraphData → 序列化存进草稿快照（closing），恢复时仍走
+ * extractFlowGraph 重建；手动编辑后也用它回存。`from` 由 edges 按 `to` 归集（带边标签）。
+ */
+export function serializeFlowGraph(data: FlowGraphData): string {
+  const fromMap = new Map<string, Array<string | { id: string; label: string }>>();
+  for (const e of data.edges) {
+    const list = fromMap.get(e.to) ?? [];
+    list.push(e.label ? { id: e.from, label: e.label } : e.from);
+    fromMap.set(e.to, list);
+  }
+  const nodes = data.nodes.map((n) => {
+    const o: Record<string, unknown> = { id: n.id, label: n.label, type: n.type };
+    if (n.group) o.group = n.group;
+    if (n.detail) o.detail = n.detail;
+    const from = fromMap.get(n.id);
+    if (from && from.length > 0) o.from = from;
+    return o;
+  });
+  return `${FLOW_FENCE_OPEN}\n${JSON.stringify({ title: data.title || "方案流程图", nodes })}\n\`\`\``;
+}
+
+/**
+ * Phase 3 画布手动编辑：改某节点的 label/group/detail（其余不变）。返回新图（不可变）。
+ */
+export function applyNodeEdit(
+  data: FlowGraphData,
+  id: string,
+  patch: { label?: string; group?: string; detail?: string },
+): FlowGraphData {
+  return {
+    ...data,
+    nodes: data.nodes.map((n) =>
+      n.id === id
+        ? {
+            ...n,
+            ...(patch.label !== undefined ? { label: patch.label.trim() || n.label } : {}),
+            // group/detail 允许清空（传空串 → 置 undefined）。
+            ...(patch.group !== undefined ? { group: patch.group.trim() || undefined } : {}),
+            ...(patch.detail !== undefined ? { detail: patch.detail.trim() || undefined } : {}),
+          }
+        : n,
+    ),
+  };
+}
+
+/**
+ * Phase 3 画布手动删除：删一个节点 + 所有与它相连的边。返回新图。
+ */
+export function deleteNodeFromGraph(data: FlowGraphData, id: string): FlowGraphData {
+  return {
+    ...data,
+    nodes: data.nodes.filter((n) => n.id !== id),
+    edges: data.edges.filter((e) => e.from !== id && e.to !== id),
+  };
+}
+
 /**
  * 识别文本（业务链编排提示 / 用户输入框消息）里是否明确要求了结构化输出 / 流程图。
  * 命中 → 总结走「流程图模式」：跳过 .md 文件，报告用文字展示 + 末尾输出 flow-json。
@@ -337,9 +421,22 @@ export interface PositionedFlowNode extends FlowGraphNode {
 export const FLOW_NODE_W = 176;
 const X_GAP = 224;
 const Y_GAP = 132;
+// 横向布局：层间走 x（节点宽 176 + 连线/标签留白），层内同层节点沿 y 堆叠。
+const LAYER_GAP_X = 248;
+const NODE_GAP_Y = 104;
 
-/** 最长路径分层（环保护：访问中的节点按 0 层处理，保证终止）。 */
-export function layoutFlowGraph(data: FlowGraphData): PositionedFlowNode[] {
+export type FlowOrientation = "vertical" | "horizontal";
+
+/**
+ * 最长路径分层（环保护：访问中的节点按 0 层处理，保证终止）。
+ *
+ * orientation="vertical"（默认）：层自上而下、同层横向铺开。
+ * orientation="horizontal"：层自左而右、同层纵向铺开（弹窗里宽屏看着更舒展）。
+ */
+export function layoutFlowGraph(
+  data: FlowGraphData,
+  orientation: FlowOrientation = "vertical",
+): PositionedFlowNode[] {
   const preds = new Map<string, string[]>();
   for (const e of data.edges) {
     const list = preds.get(e.to);
@@ -370,10 +467,19 @@ export function layoutFlowGraph(data: FlowGraphData): PositionedFlowNode[] {
 
   const pos = new Map<string, { x: number; y: number }>();
   for (const [layer, nodes] of byLayer) {
-    const rowWidth = (nodes.length - 1) * X_GAP;
-    nodes.forEach((n, i) => {
-      pos.set(n.id, { x: i * X_GAP - rowWidth / 2, y: layer * Y_GAP });
-    });
+    if (orientation === "horizontal") {
+      // 层 → x，同层节点沿 y 居中堆叠。
+      const colHeight = (nodes.length - 1) * NODE_GAP_Y;
+      nodes.forEach((n, i) => {
+        pos.set(n.id, { x: layer * LAYER_GAP_X, y: i * NODE_GAP_Y - colHeight / 2 });
+      });
+    } else {
+      // 层 → y，同层节点沿 x 居中铺开（原默认）。
+      const rowWidth = (nodes.length - 1) * X_GAP;
+      nodes.forEach((n, i) => {
+        pos.set(n.id, { x: i * X_GAP - rowWidth / 2, y: layer * Y_GAP });
+      });
+    }
   }
   // 保持原始（流式）顺序输出，方便调用方做「最新节点」判断。
   return data.nodes.map((n) => ({ ...n, ...pos.get(n.id)! }));

frontend-web/src/roundtable-planning/lib/job-live.ts

@@ -66,6 +66,10 @@ function toStep2Dialogue(d: JobDialogue, idxByAgent: Map<string, number>): Step2
   if (d.role === "leader") {
     return { ...base, sender: "总控协调", avatarType: "blue", confidence: "派活说明" };
   }
+  // 模型自动容错的系统提示气泡（后端 progress.model_switch 以 role="system" 落库）。
+  if (d.role === "system") {
+    return { ...base, sender: d.name || "系统提示", avatarType: "amber", confidence: "模型容错" };
+  }
   const aid = d.agentId ?? "";
   return {
     ...base,

frontend-web/src/roundtable-planning/lib/job-types.ts

@@ -52,7 +52,8 @@ export interface DispatchChainNode {
 /** 一条研讨对话记录（leader 说明 / 某席位交付）。 */
 export interface JobDialogue {
   id: number;
-  role: "leader" | "seat";
+  // "system" = 模型自动容错等系统提示气泡（后端 progress.model_switch 落库）。
+  role: "leader" | "seat" | "system";
   agentId: string | null;
   name: string;
   content: string;
@@ -107,6 +108,11 @@ export interface RoundtableJob {
 /** 启动一个后台作业的入参（对齐后端 `StartJobRequest`）。 */
 export interface StartJobPayload {
   draftId?: string | null;
+  /**
+   * 外部任务 id（taskId 深链会商）。非空 = task 作业：按 task_id 共享、不按 user 分权，
+   * 其 draft_id 指向独立的 task-draft 存储（最终报告写回那里）。
+   */
+  taskId?: string | null;
   /** 任务意图；缺省 seedMessage 时用它作第一轮 leader prompt。 */
   intent: string;
   /** 有序席位（recommend=选择顺序 / chain=链条顺序）。 */
@@ -127,6 +133,26 @@ export interface StartJobPayload {
    * reasoning/subagent 三字段发给后端。
    */
   seatMode?: SeatMode;
+  /**
+   * 每席位「技能识别强化」开关映射 {agentId: bool}（沿用所选业务链条里每个席位的配置）。
+   * 后台席位 run 按 agentId 查表（与各席位智能体自身的同名开关取 OR）决定是否注入。缺省 {}。
+   */
+  seatSkillDirectives?: Record<string, boolean>;
+  /**
+   * 每席位「推理深度覆盖」映射 {agentId: SeatMode | null}（沿用所选业务链条里每个席位单独配的
+   * 推理深度）。后台席位 run 按 agentId 查表，覆盖优先、否则跟随链条级 `seatMode`。缺省 {}。
+   */
+  seatModes?: Record<string, SeatMode | null>;
+  /**
+   * 「研讨前并行取数」开关（来源链条的 gatherFirst）。true = 后台作业研讨前先并行取数再研讨。
+   * 在 `toStartBody` 里下发为后端 `gather_first`。缺省 false。
+   */
+  gatherFirst?: boolean;
+  /**
+   * 深链接业务码（rwfx→6BF 等）。透传给后台总结报告的「业务链完整性核对」（写实业务如 rwfx 才生效）。
+   * 普通会商省略。`toStartBody` 里下发为后端 `business_code`。
+   */
+  businessCode?: string | null;
 }
 
 /** 终态集合——SSE/轮询判定作业是否结束。 */

frontend-web/src/roundtable-planning/lib/report-template.test.ts

@@ -67,6 +67,32 @@ test("extractReportData：dependsOn 只保留真实存在的席位 id（剔除
   assert.deepEqual(d.seats[0].dependsOn, ["s2"]);
 });
 
+test("extractReportData：剥离 <think> 思考过程后再抽取（思考里的假 JSON 不干扰）", () => {
+  // 思考块里故意混入一个会「像」契约但不该被采用的裸 JSON，正文才是真数据。
+  const withThink = [
+    "<think>",
+    '我先草拟一版：{"title":"草稿不要用","seats":[{"id":"x","name":"废弃"}]}',
+    "再想想……",
+    "</think>",
+    SAMPLE,
+  ].join("\n");
+  const d = extractReportData(withThink)!;
+  assert.equal(d.title, "智能机房选址方案大屏");
+  assert.equal(d.seats.length, 2);
+});
+
+test("extractReportData：只吐闭合 </think>（chat template 注入式）也能抽到正文", () => {
+  const onlyClose = ["模型在此思考成本与风险……", "</think>", SAMPLE].join("\n");
+  const d = extractReportData(onlyClose)!;
+  assert.equal(d.title, "智能机房选址方案大屏");
+});
+
+test("extractReportData：流式未闭合 <think> 尾段不被误抽（返回 null）", () => {
+  // 正文还没出，模型还在思考里写了半个 JSON —— 不应抽出数据。
+  const streaming = '正文前导\n<think>我打算输出 {"title":"在想","seats":[{"id":"a","name":"甲"';
+  assert.equal(extractReportData(streaming), null);
+});
+
 test("extractReportData：无 fence / 坏 JSON / 空数据返回 null", () => {
   assert.equal(extractReportData("没有数据块"), null);
   assert.equal(extractReportData("```report-json\n{broken\n```"), null);

frontend-web/src/roundtable-planning/lib/report-template.ts

@@ -34,6 +34,7 @@
  */
 
 import darkBgSvgRaw from "@/assets/img/layout-bg-theme-dark-blue.svg?raw";
+import { stripReasoning } from "@/roundtable-planning/lib/reasoning";
 
 // ── 契约类型 ─────────────────────────────────────────────────────────────────
 
@@ -207,18 +208,23 @@ function arr(v: unknown): unknown[] {
  */
 export function extractReportData(text: string | null | undefined): ReportData | null {
   if (!text) return null;
+  // 容错：先剥离模型 `<think>...</think>` 思考过程（兼容完整/多段/流式未闭合/只吐闭合等
+  // 形态，见 reasoning.ts）。否则思考里出现的 ```json / 裸 {…} 会被误当候选，抽到错误或
+  // 残缺数据（与「抽取结构化流程」同款容错）。无 think 标记时原样返回，仅去首尾空白。
+  const cleaned = stripReasoning(text);
+  if (!cleaned) return null;
   const candidates: string[] = [];
   const rank = (lang: string) =>
     lang === "report-json" ? 0 : lang === "json" || lang === "jsonc" ? 1 : lang === "" ? 2 : 3;
-  collectFencedBlocks(text)
+  collectFencedBlocks(cleaned)
     .map((b, i) => ({ b, i }))
     .sort((x, y) => rank(x.b.lang) - rank(y.b.lang) || y.i - x.i)
     .forEach(({ b }) => candidates.push(b.body));
   // 未闭合围栏（流式截断）：取 report-json fence 之后到结尾。
-  const f = text.lastIndexOf(FENCE);
-  if (f >= 0) candidates.push(text.slice(f + FENCE.length).trim());
+  const f = cleaned.lastIndexOf(FENCE);
+  if (f >= 0) candidates.push(cleaned.slice(f + FENCE.length).trim());
   // 裸 JSON（无围栏 / 夹在文字里）：所有顶层平衡 {…} 对象，靠后的先试，契约形状的优先。
-  const objs = balancedJsonObjects(text);
+  const objs = balancedJsonObjects(cleaned);
   for (const o of objs.filter(looksLikeReportJson).reverse()) candidates.push(o);
   for (const o of objs.reverse()) candidates.push(o);
 
@@ -351,6 +357,22 @@ export function coerceReportData(raw: unknown): ReportData | null {
 
 // ── 模型 prompt（只要 report-json，不调工具、不写文件） ───────────────────────────
 
+/** ```report-json 契约说明（buildDashboardPrompt / buildDashboardPromptFromJson 共用）。 */
+const DASHBOARD_REPORT_JSON_CONTRACT = [
+  "```report-json 契约（严格 JSON，全程简体中文）：",
+  '{"title":"大屏主标题（≤20字）","subtitle":"一句话定位",',
+  ' "kpis":[{"label":"指标名","value":"数值","unit":"单位","trend":"up|down|flat"}],  // 3-6 个核心指标，从内容提取或合理估算',
+  ' "consensus":{"headline":"一句话最终结论","points":["结论要点，3-6 条"]},',
+  ' "charts":[{"type":"line|bar|donut|radar","title":"图表标题","items":[{"label":"维度","value":数字}]}],  // 1-3 个总览图表：line=趋势(销量/渗透率随时间)、donut=占比(份额/构成)、radar=多维对比(竞争力)、bar=排名；3-8 项/图',
+  ' "timeline":[{"label":"阶段名","desc":"一句话说明"}],  // 执行路线 3-6 阶段',
+  ' "seats":[{"id":"seat-1","name":"分区/角色名","summary":"该分区结论一两句",',
+  '   "sections":[{"heading":"小节标题","bullets":["要点，每条≤40字"]}],  // 2-4 节',
+  '   "metrics":[{"label":"量化指标名","value":0到100}],  // 0-3 个',
+  '   "risks":[{"label":"风险点","level":"high|mid|low"}],  // 0-4 个',
+  '   "dependsOn":["它承接哪些分区的产物（分区id）"]}]}  // 依据内容判断依赖关系',
+  "硬性要求：id 用 seat-1..seat-N；dependsOn 只引用本清单内的 id；JSON 必须可被 JSON.parse 解析（无注释、无尾逗号）。",
+].join("\n");
+
 export function buildDashboardPrompt(opts: {
   intentText: string;
   seatDeliveries: Array<{ sender: string; content: string }>;
@@ -374,24 +396,45 @@ export function buildDashboardPrompt(opts: {
   parts.push((opts.consensusText || "").trim() || "（未提供）");
   parts.push("");
   parts.push(
-    [
-      "```report-json 契约（严格 JSON，全程简体中文）：",
-      '{"title":"大屏主标题（≤20字）","subtitle":"一句话定位",',
-      ' "kpis":[{"label":"指标名","value":"数值","unit":"单位","trend":"up|down|flat"}],  // 3-6 个核心指标，从研讨内容提取或合理估算',
-      ' "consensus":{"headline":"一句话最终结论","points":["结论要点，3-6 条"]},',
-      ' "charts":[{"type":"line|bar|donut|radar","title":"图表标题","items":[{"label":"维度","value":数字}]}],  // 1-3 个总览图表：line=趋势(销量/渗透率随时间)、donut=占比(份额/构成)、radar=多维对比(竞争力)、bar=排名；3-8 项/图',
-      ' "timeline":[{"label":"阶段名","desc":"一句话说明"}],  // 执行路线 3-6 阶段',
-      ' "seats":[{"id":"seat-1","name":"席位名（与交付席位一致）","summary":"该席位结论一两句",',
-      '   "sections":[{"heading":"小节标题","bullets":["要点，每条≤40字"]}],  // 2-4 节，提炼该席位交付',
-      '   "metrics":[{"label":"量化指标名","value":0到100}],  // 0-3 个',
-      '   "risks":[{"label":"风险点","level":"high|mid|low"}],  // 0-4 个',
-      '   "dependsOn":["它承接哪些席位的产物（席位id）"]}]}  // 每个交付席位一项；依据交付内容判断依赖关系',
-      "硬性要求：seats 覆盖**每一个**有交付的席位；id 用 seat-1..seat-N；dependsOn 只引用本清单内的 id；JSON 必须可被 JSON.parse 解析（无注释、无尾逗号）。",
-    ].join("\n"),
+    DASHBOARD_REPORT_JSON_CONTRACT.replace(
+      "硬性要求：id",
+      "硬性要求：seats 覆盖**每一个**有交付的席位；id",
+    ),
   );
   return parts.join("\n");
 }
 
+/**
+ * 大屏绘制智能体（独立页面）的初始 prompt：输入是外部系统给的**任意结构 JSON**，
+ * 让智能体**分析/转换**成大屏所需的 report-json 结构。区别于 buildDashboardPrompt
+ * （输入是圆桌研讨成果），这里输入是登录时拉取的任务原始数据。
+ *
+ * 注：现在 JSON 接口未就绪，调用方传的是占位数据（任务名/内容等）；接口就绪后改为
+ * 后台转换格式 + 智能体校验，仍由本智能体产出/校验 report-json（不后台硬抽）。
+ */
+export function buildDashboardPromptFromJson(inputJson: unknown): string {
+  let inputText: string;
+  try {
+    inputText =
+      typeof inputJson === "string" ? inputJson : JSON.stringify(inputJson, null, 2);
+  } catch {
+    inputText = String(inputJson ?? "");
+  }
+  return [
+    "【结构化数据模式】本轮**不要调用任何工具、不要写任何文件、不要输出 HTML**。",
+    "下面是本任务的**原始数据（JSON）**。请你**分析并转换**它，提炼成一份用于「研讨大屏」展示的结构化数据：",
+    "理解原始数据的业务含义，归纳关键指标、结论、图表维度、分阶段路线，以及若干主题分区（seats，按业务维度/模块拆分，不必对应真实席位）。",
+    "在回复**最末尾**输出一个完整的 ```report-json 代码块（契约见下），代码块之外只允许一两句简短说明。",
+    "",
+    "# 任务原始数据（JSON）",
+    "```json",
+    inputText.trim() || "（未提供）",
+    "```",
+    "",
+    DASHBOARD_REPORT_JSON_CONTRACT,
+  ].join("\n");
+}
+
 // ── 主题（2026-06-13）：跟随应用当前主题绘制 ─────────────────────────────────────
 // light = 《浅红色 UI 规范》(docs/浅红色UI规范)：白/浅灰大底、#F5222D 品牌红强调、
 //         卡片 4px 圆角、语义色 成功#189D72/警告#FF9900/错误#F5222D/信息#0079FE；

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

@@ -27,6 +27,7 @@ import {
   Bot,
   ChevronDown,
   ChevronUp,
+  Gauge,
   GitBranch,
   Globe,
   GripVertical,
@@ -37,6 +38,7 @@ import {
   Plus,
   Save,
   Sliders,
+  Sparkles,
   SplitSquareVertical,
   Trash2,
   UserPlus,
@@ -63,9 +65,20 @@ import {
 import { CSS } from "@dnd-kit/utilities";
 
 import { cn } from "@/lib/utils";
+import {
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from "@/components/ui/dropdown-menu";
+import { Switch } from "@/components/ui/switch";
 import { useDesensitizeSubtree } from "@/roundtable-planning/lib/use-desensitize-subtree";
 import { TagSearchBar } from "@/components/workspace/tags/tag-search-bar";
+import { ModelNameSelect } from "@/components/workspace/model-name-select";
 import { listAgents } from "@/core/agents";
+import { getStoredAuth } from "@/core/auth";
 
 import {
   filterRecommendCandidates,
@@ -74,6 +87,7 @@ import {
 import {
   createChain,
   deleteChain,
+  getChain,
   listChains,
   optimizeChainPrompt,
   setChainPublic,
@@ -103,6 +117,9 @@ import {
   moveStage,
   removeSeat as removeSeatFromGroups,
   seatExistsInGroups,
+  setSeatMode as setSeatModeOnGroups,
+  setSeatModel,
+  setSeatSkillDirective,
   setStageGoal,
   splitSeatToNewStage,
   stageGroupsToSeats,
@@ -156,6 +173,8 @@ export default function BusinessChainEditorPage() {
   // 当前编辑链条的发布状态 / 是否本人所有（发布按钮 + 只读保护用）。
   const [currentChainPublic, setCurrentChainPublic] = useState(false);
   const [currentChainMine, setCurrentChainMine] = useState(true);
+  // 管理员：可编辑 / 发布 / 删除任意账号的链条（与「全部链条」筛选配套）。
+  const isAdmin = getStoredAuth()?.system_role === "admin";
   const [publishing, setPublishing] = useState(false);
   const [title, setTitle] = useState("");
   const [description, setDescription] = useState("");
@@ -163,6 +182,8 @@ export default function BusinessChainEditorPage() {
   const [coordinatorPrompt, setCoordinatorPrompt] = useState("");
   // 默认席位执行模式（快速/思考/专业问答/多智能体）—— 选入研讨时弹窗默认用它。
   const [seatMode, setSeatMode] = useState<SeatMode>(DEFAULT_SEAT_MODE);
+  // 链条级「研讨前并行取数」开关（逐条 opt-in，默认关）：开 = 选入研讨时研讨前先并行取数再研讨。
+  const [gatherFirst, setGatherFirst] = useState<boolean>(false);
   // 分层编排是唯一数据源；落库时展平为 seats + 折叠为 stages。
   const [stageGroups, setStageGroups] = useState<StageGroups>([]);
   const [saving, setSaving] = useState(false);
@@ -288,6 +309,7 @@ export default function BusinessChainEditorPage() {
     setDescription(chain.description ?? "");
     setCoordinatorPrompt(chain.coordinatorPrompt ?? "");
     setSeatMode(chain.seatMode ?? DEFAULT_SEAT_MODE);
+    setGatherFirst(chain.gatherFirst ?? false);
     setStageGroups(chainToStageGroups(chain));
     setStep(1);
   }, []);
@@ -300,21 +322,40 @@ export default function BusinessChainEditorPage() {
     setDescription("");
     setCoordinatorPrompt("");
     setSeatMode(DEFAULT_SEAT_MODE);
+    setGatherFirst(false);
     setStageGroups([]);
     setStep(1);
   }, []);
 
-  // ─── URL 参数 chainId：从「业务链条」弹窗点「设置」进来时自动切到该链条 ──────
-  // 只在链条列表加载完后应用一次（用 ref 闸门避免覆盖用户后续的手动切换）。
-  const appliedChainParamRef = useRef(false);
+  // ─── URL 参数 chainId：从「业务链条」弹窗 / 列表点「设置」进来时自动切到该链条 ──────
+  // 按「已应用的 chainId」做闸门（而非「只应用一次」）：当 URL 的 chainId 变化时重新加载。
+  // 关键修复：此编辑器实例在多次导航间可能不卸载（从弹窗进来时尤甚），用「只应用一次」的
+  // 旧闸门会导致第二次打开另一条链条时根本不加载，currentChainId 停在上一条 → 保存打到错误
+  // 的 id → 后端 404「已删除」，必须重新登录（整页刷新重建组件）才恢复。改为追踪已应用的 id
+  // 后，chainId 变了就重载；同一 chainId 不重复加载，也不覆盖用户在编辑器内的手动切换。
+  const appliedChainIdRef = useRef<string | null>(null);
   useEffect(() => {
-    if (appliedChainParamRef.current) return;
     const chainId = searchParams.get("chainId");
     if (!chainId) return;
-    if (chains.length === 0) return; // 等 refreshChains 拉回列表
-    const chain = chains.find((c) => c.id === chainId);
-    if (chain) loadChain(chain);
-    appliedChainParamRef.current = true; // 命中或链条已不存在，都不再重试
+    if (appliedChainIdRef.current === chainId) return; // 这条已加载过，别覆盖用户后续操作
+    appliedChainIdRef.current = chainId;
+    // 优先用「我的链条」列表里已拉到的对象（省一次请求）；不在列表里（管理员从「全部链条」
+    // 点设置 / 公共链条 / 自己没有任何链条）则直接按 id 拉取。后端对管理员放开任意链条、
+    // 对所有人放开已发布公共链条；拉不到给出提示并保持空白新建态。
+    const local = chains.find((c) => c.id === chainId);
+    if (local) {
+      loadChain(local);
+      return;
+    }
+    void (async () => {
+      try {
+        const chain = await getChain(chainId);
+        if (chain) loadChain(chain);
+        else toast.error("该业务链条不存在或无权访问");
+      } catch {
+        // 静默：取不到就保持当前（空白）状态。
+      }
+    })();
   }, [chains, searchParams, loadChain]);
 
   // ─── 席位增删改（全部委托给 lib/chain-stages 纯函数）────────────────────
@@ -359,6 +400,21 @@ export default function BusinessChainEditorPage() {
     setStageGroups((prev) => setStageGoal(prev, stageIdx, goal));
   }, []);
 
+  // 席位模型覆盖：编辑器席位下拉 onChange（null = 清除，跟随全局）。
+  const setSeatModelCb = useCallback((agentId: string, model: string | null) => {
+    setStageGroups((prev) => setSeatModel(prev, agentId, model));
+  }, []);
+
+  // 席位「会商技能识别强化」开关：编辑器席位下拉 onChange。
+  const setSeatSkillDirectiveCb = useCallback((agentId: string, enabled: boolean) => {
+    setStageGroups((prev) => setSeatSkillDirective(prev, agentId, enabled));
+  }, []);
+
+  // 席位「推理深度覆盖」：编辑器席位小图标下拉 onChange（null = 清除，跟随链条级 seatMode）。
+  const setSeatModeCb = useCallback((agentId: string, mode: SeatMode | null) => {
+    setStageGroups((prev) => setSeatModeOnGroups(prev, agentId, mode));
+  }, []);
+
   // ── 提示词 AI 优化（总控提示词 / 各 Stage 阶段目标）────────────────────────
   const [optimizingCoordinator, setOptimizingCoordinator] = useState(false);
   const [goalOptimizingIdx, setGoalOptimizingIdx] = useState<number | null>(null);
@@ -555,6 +611,12 @@ export default function BusinessChainEditorPage() {
           agent_id: s.agent_id,
           name: live?.name ?? s.name,
           description: live?.description ?? s.description ?? "",
+          // 席位模型覆盖：随席位一起落库（空 → null = 跟随全局）。
+          model: s.model ?? null,
+          // 席位「会商技能识别强化」开关：随席位一起落库（缺省 = false 关）。
+          seat_skill_directive: s.seat_skill_directive ?? false,
+          // 席位「推理深度覆盖」：随席位一起落库（null = 跟随链条级 seatMode）。
+          seat_mode: s.seat_mode ?? null,
         };
       });
       // 总控编排提示：trim 后空串落 null（清空），与后端「空=不注入」一致。
@@ -573,6 +635,7 @@ export default function BusinessChainEditorPage() {
           stageGoals,
           coordinatorPrompt: coordPrompt,
           seatMode,
+          gatherFirst,
         });
         if (!updated) {
           toast.error("链条已不存在，可能被删除");
@@ -592,6 +655,7 @@ export default function BusinessChainEditorPage() {
           stageGoals,
           coordinatorPrompt: coordPrompt,
           seatMode,
+          gatherFirst,
         });
         setCurrentChainId(created.id);
         toast.success("已创建业务链条");
@@ -607,6 +671,7 @@ export default function BusinessChainEditorPage() {
     description,
     coordinatorPrompt,
     seatMode,
+    gatherFirst,
     stageGroups,
     seatCountInvalid,
     currentChainId,
@@ -745,6 +810,22 @@ export default function BusinessChainEditorPage() {
         </p>
       </div>
 
+      {/* 研讨前并行取数：逐条 opt-in 的提速开关（默认关）。 */}
+      <div className={cn("flex items-start justify-between gap-3 border border-border bg-muted/30 p-3", R_CARD)}>
+        <div className="space-y-1">
+          <label className="flex items-center gap-1 text-xs font-semibold text-foreground">
+            <Gauge className="size-3.5 text-primary" />
+            研讨前并行取数（提速）
+          </label>
+          <p className="text-[11px] leading-relaxed text-muted-foreground">
+            开启后，选入研讨时会**先并行跑一轮「只取数」**：各席位同时用技能把相关信息收集回来（不研讨），
+            产出作为共享资料注入后续研讨轮。把最慢的技能检索前置、并行做一次，给（尤其按链条顺序串行的）
+            研讨段大幅提速；研讨阶段席位仍可按需再调技能。
+          </p>
+        </div>
+        <Switch checked={gatherFirst} onCheckedChange={setGatherFirst} className="mt-0.5 shrink-0" />
+      </div>
+
       {/* 总控提示词：label + AI 优化（配色沿用现有 primary）+ 大号等宽编辑区 */}
       <div className="space-y-2">
         <div className="flex items-center justify-between gap-2">
@@ -928,8 +1009,8 @@ export default function BusinessChainEditorPage() {
 
         {/* 右侧操作 */}
         <div className="ml-auto flex items-center gap-2">
-          {/* 发布 / 取消发布：仅已保存且本人所有的链条。发布后所有账号可在「公共」筛选查看 / 选用。 */}
-          {currentChainId && currentChainMine && (
+          {/* 发布 / 取消发布：已保存且本人所有（或管理员）的链条。发布后所有账号可在「公共」筛选查看 / 选用。 */}
+          {currentChainId && (currentChainMine || isAdmin) && (
             <button
               type="button"
               onClick={handleTogglePublish}
@@ -1121,6 +1202,9 @@ export default function BusinessChainEditorPage() {
             onRemoveSeat={removeSeat}
             onMergeSeat={mergeSeatToStage}
             onSplitSeat={splitSeat}
+            onSeatModelChange={setSeatModelCb}
+            onSeatSkillDirectiveChange={setSeatSkillDirectiveCb}
+            onSeatModeChange={setSeatModeCb}
             onStageGoalChange={setGoal}
             goalOptimizingIdx={goalOptimizingIdx}
             onOptimizeGoal={handleOptimizeStageGoal}
@@ -1298,6 +1382,9 @@ function StagesColumn({
   onRemoveSeat,
   onMergeSeat,
   onSplitSeat,
+  onSeatModelChange,
+  onSeatSkillDirectiveChange,
+  onSeatModeChange,
   onStageGoalChange,
   goalOptimizingIdx,
   onOptimizeGoal,
@@ -1313,6 +1400,9 @@ function StagesColumn({
   onRemoveSeat: (agentId: string) => void;
   onMergeSeat: (agentId: string, targetStageIdx: number) => void;
   onSplitSeat: (agentId: string) => void;
+  onSeatModelChange: (agentId: string, model: string | null) => void;
+  onSeatSkillDirectiveChange: (agentId: string, enabled: boolean) => void;
+  onSeatModeChange: (agentId: string, mode: SeatMode | null) => void;
   onStageGoalChange: (stageIdx: number, goal: string) => void;
   /** 正在 AI 优化阶段目标的 stage 下标（null = 没有进行中的优化）。 */
   goalOptimizingIdx: number | null;
@@ -1410,6 +1500,9 @@ function StagesColumn({
                 onRemoveSeat={onRemoveSeat}
                 onMergeSeat={onMergeSeat}
                 onSplitSeat={onSplitSeat}
+                onSeatModelChange={onSeatModelChange}
+                onSeatSkillDirectiveChange={onSeatSkillDirectiveChange}
+                onSeatModeChange={onSeatModeChange}
                 onGoalChange={(goal) => onStageGoalChange(stageIdx, goal)}
                 goalOptimizing={goalOptimizingIdx === stageIdx}
                 anyGoalOptimizing={goalOptimizingIdx !== null}
@@ -1438,6 +1531,9 @@ function StageSection({
   onRemoveSeat,
   onMergeSeat,
   onSplitSeat,
+  onSeatModelChange,
+  onSeatSkillDirectiveChange,
+  onSeatModeChange,
   onGoalChange,
   goalOptimizing,
   anyGoalOptimizing,
@@ -1455,6 +1551,9 @@ function StageSection({
   onRemoveSeat: (agentId: string) => void;
   onMergeSeat: (agentId: string, targetStageIdx: number) => void;
   onSplitSeat: (agentId: string) => void;
+  onSeatModelChange: (agentId: string, model: string | null) => void;
+  onSeatSkillDirectiveChange: (agentId: string, enabled: boolean) => void;
+  onSeatModeChange: (agentId: string, mode: SeatMode | null) => void;
   onGoalChange: (goal: string) => void;
   /** 本 Stage 的阶段目标正在 AI 优化中。 */
   goalOptimizing: boolean;
@@ -1615,6 +1714,9 @@ function StageSection({
                 onMergeUp={() => onMergeSeat(seat.agent_id, stageIdx - 1)}
                 onMergeDown={() => onMergeSeat(seat.agent_id, stageIdx + 1)}
                 onSplit={() => onSplitSeat(seat.agent_id)}
+                onModelChange={(model) => onSeatModelChange(seat.agent_id, model)}
+                onSkillDirectiveChange={(enabled) => onSeatSkillDirectiveChange(seat.agent_id, enabled)}
+                onSeatModeChange={(mode) => onSeatModeChange(seat.agent_id, mode)}
                 onDetail={() => onSeatDetail(seat.agent_id, seat.name)}
               />
             ))}
@@ -1637,6 +1739,9 @@ function SeatStrip({
   onMergeUp,
   onMergeDown,
   onSplit,
+  onModelChange,
+  onSkillDirectiveChange,
+  onSeatModeChange,
   onDetail,
 }: {
   seat: ChainSeat;
@@ -1649,6 +1754,12 @@ function SeatStrip({
   onMergeUp: () => void;
   onMergeDown: () => void;
   onSplit: () => void;
+  /** 席位模型覆盖变更（null = 清除，跟随全局）。 */
+  onModelChange: (model: string | null) => void;
+  /** 席位「会商技能识别强化」开关变更。 */
+  onSkillDirectiveChange: (enabled: boolean) => void;
+  /** 席位「推理深度覆盖」变更（null = 跟随链条级 seatMode）。 */
+  onSeatModeChange: (mode: SeatMode | null) => void;
   onDetail: () => void;
 }) {
   const { attributes, listeners, setNodeRef, transform, transition, isDragging } =
@@ -1699,8 +1810,106 @@ function SeatStrip({
         )}
       </div>
 
-      {/* 控制：查看详情 / 并入上一阶段 / 独立成阶段 / 并入下一阶段 / 移除 */}
+      {/* 席位模型覆盖（右侧操作区）：空 = 跟随全局所选模型；选了则该席位作为子智能体
+          执行时用此模型。技能重的席位配强模型、边角席位配快模型，配合技能白名单实现
+          「强弱搭配」。放到右侧操作区，与名称/描述解耦，卡片更整洁。 */}
+      <div className="flex shrink-0 items-center border-l border-border px-2.5">
+        <div
+          className={cn(
+            "flex items-center gap-1.5 border border-border/70 bg-muted/40 py-1 pl-2 pr-1",
+            R_CTRL,
+          )}
+          title="该席位作为子智能体执行时使用的模型；「跟随全局」= 用第二步顶部所选模型"
+        >
+          <span className="shrink-0 select-none text-[10px] font-medium text-muted-foreground">模型</span>
+          <ModelNameSelect
+            value={seat.model ?? null}
+            onChange={onModelChange}
+            defaultLabel="跟随全局"
+            triggerClassName="h-6 max-w-[150px] border-none bg-transparent text-[11px] shadow-none hover:bg-background/60"
+          />
+        </div>
+      </div>
+
+      {/* 控制：推理深度 / 技能识别强化 / 查看详情 / 并入上一阶段 / 独立成阶段 / 并入下一阶段 / 移除 */}
       <div className="flex shrink-0 items-center gap-0.5 border-l border-border px-2">
+        {/* 席位推理深度覆盖：小图标 → 下拉框（跟随链条默认 + 四档）。设了覆盖 = 高亮。
+            「卡顿提速」用：把信息收集/边角席位降到「快速」，只给关键席位留「专业/多智能体」。 */}
+        <DropdownMenu>
+          <DropdownMenuTrigger asChild>
+            <button
+              type="button"
+              title="席位推理深度（覆盖链条默认；降到「快速」可在模型卡顿时大幅提速）"
+              className={cn(
+                "p-1 transition",
+                R_CTRL,
+                seat.seat_mode
+                  ? "bg-primary/10 text-primary"
+                  : "text-muted-foreground hover:bg-muted hover:text-foreground",
+              )}
+            >
+              <Gauge className="size-3.5" />
+            </button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="end" className="w-60">
+            <DropdownMenuLabel className="text-[11px] font-semibold">
+              席位推理深度
+              <span className="mt-0.5 block text-[10px] font-normal text-muted-foreground">
+                覆盖链条级默认，仅本席位生效。模型卡顿时把次要席位降到「快速」可大幅提速。
+              </span>
+            </DropdownMenuLabel>
+            <DropdownMenuSeparator />
+            <DropdownMenuItem
+              className={cn("text-xs", !seat.seat_mode && "font-semibold text-primary")}
+              onClick={() => onSeatModeChange(null)}
+            >
+              跟随链条默认
+            </DropdownMenuItem>
+            {SEAT_MODE_OPTIONS.map((opt) => (
+              <DropdownMenuItem
+                key={opt.value}
+                className={cn("flex-col items-start gap-0 text-xs", seat.seat_mode === opt.value && "font-semibold text-primary")}
+                onClick={() => onSeatModeChange(opt.value)}
+              >
+                <span>{opt.label}</span>
+                <span className="text-[10px] font-normal leading-tight text-muted-foreground">{opt.description}</span>
+              </DropdownMenuItem>
+            ))}
+          </DropdownMenuContent>
+        </DropdownMenu>
+        {/* 会商技能识别强化：小图标 → 下拉框（开关 + 说明）。开启 = 高亮。 */}
+        <DropdownMenu>
+          <DropdownMenuTrigger asChild>
+            <button
+              type="button"
+              title="会商技能识别强化（弱模型补偿）"
+              className={cn(
+                "p-1 transition",
+                R_CTRL,
+                seat.seat_skill_directive
+                  ? "bg-primary/10 text-primary"
+                  : "text-muted-foreground hover:bg-muted hover:text-foreground",
+              )}
+            >
+              <Sparkles className="size-3.5" />
+            </button>
+          </DropdownMenuTrigger>
+          <DropdownMenuContent align="end" className="w-64 p-3">
+            <div className="flex items-start justify-between gap-3">
+              <div className="space-y-0.5">
+                <p className="text-xs font-semibold text-foreground">会商技能识别强化</p>
+                <p className="text-[11px] leading-relaxed text-muted-foreground">
+                  开启后，该席位作为会商子智能体执行时，会把已配置的技能（含 SKILL.md
+                  路径与「先 read_file 再用」硬指令）拼进任务，补偿弱模型不识别技能。也可在该智能体编辑里打开（任一即生效）。
+                </p>
+              </div>
+              <Switch
+                checked={seat.seat_skill_directive ?? false}
+                onCheckedChange={onSkillDirectiveChange}
+              />
+            </div>
+          </DropdownMenuContent>
+        </DropdownMenu>
         <button
           type="button"
           onClick={onDetail}

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

@@ -61,6 +61,7 @@ import {
   DialogHeader,
   DialogTitle,
 } from "@/components/ui/dialog";
+import { getStoredAuth } from "@/core/auth";
 import { useRouteNavigate } from "@/core/route-base";
 import { cn } from "@/lib/utils";
 import { useDesensitizeSubtree } from "@/roundtable-planning/lib/use-desensitize-subtree";
@@ -83,6 +84,8 @@ export default function BusinessChainListPage() {
   const navigate = useRouteNavigate();
   // 整片脱敏：链条列表页展示文本（链条名/描述/席位名/标题）。
   const dzRef = useDesensitizeSubtree<HTMLDivElement>();
+  // 管理员：额外多一个「全部链条」筛选，且可编辑 / 发布 / 删除任意账号的链条。
+  const isAdmin = getStoredAuth()?.system_role === "admin";
 
   // 进入编辑器：带 chainId = 打开并切到该链条；不带 = 空白新建。
   // 路径写 workspace base，`useRouteNavigate` 会按当前路由 base 改写。
@@ -314,13 +317,14 @@ export default function BusinessChainListPage() {
 
           {/* 筛选工具栏 */}
           <div className="mb-6 flex flex-col gap-4 rounded-2xl border border-zinc-100 bg-white p-4 shadow-sm dark:border-[#1A2F5A] dark:bg-[#122347] lg:flex-row lg:items-center lg:justify-between">
-            {/* 我的 / 公共 */}
+            {/* 我的 / 公共 /（管理员）全部 */}
             <div className="flex self-start rounded-xl bg-zinc-100 p-1 dark:bg-[#0C1836]">
               {(
                 [
                   ["mine", "我的链条"],
                   ["public", "公共列表"],
-                ] as const
+                  ...(isAdmin ? ([["all", "全部链条"]] as const) : []),
+                ] as [ChainScope, string][]
               ).map(([key, label]) => (
                 <button
                   key={key}
@@ -439,6 +443,7 @@ export default function BusinessChainListPage() {
                   <ChainCard
                     key={chain.id}
                     chain={chain}
+                    canManage={isAdmin || chain.isMine !== false}
                     publishing={publishingId === chain.id}
                     onSettings={() => goConfigure(chain.id)}
                     onTogglePublic={() => handleTogglePublic(chain)}
@@ -450,6 +455,7 @@ export default function BusinessChainListPage() {
           ) : (
             <ChainTable
               chains={visibleChains}
+              canManage={isAdmin}
               publishingId={publishingId}
               onSettings={(c) => goConfigure(c.id)}
               onTogglePublic={handleTogglePublic}
@@ -620,18 +626,20 @@ function EmptyState({
 
 function ChainCard({
   chain,
+  canManage,
   publishing,
   onSettings,
   onTogglePublic,
   onDelete,
 }: {
   chain: BusinessChain;
+  /** 能否编辑 / 发布 / 删除（本人链条 或 管理员）。 */
+  canManage: boolean;
   publishing: boolean;
   onSettings: () => void;
   onTogglePublic: () => void;
   onDelete: () => void;
 }) {
-  const isMine = chain.isMine !== false;
   const ownerName = chain.ownerName ? chain.ownerName.split("@")[0] : "";
 
   return (
@@ -685,8 +693,8 @@ function ChainCard({
             </div>
           </div>
 
-          {/* 操作按钮：仅本人链条可发布 / 设置 / 删除（公共里别人的链条只读浏览）。 */}
-          {isMine && (
+          {/* 操作按钮：本人链条或管理员可发布 / 设置 / 删除（普通用户看别人的链条只读浏览）。 */}
+          {canManage && (
             <div className="flex shrink-0 items-center gap-1 opacity-80 transition-opacity group-hover:opacity-100">
               <button
                 type="button"
@@ -892,12 +900,15 @@ function dotClass(avatarType: string): string {
 
 function ChainTable({
   chains,
+  canManage,
   publishingId,
   onSettings,
   onTogglePublic,
   onDelete,
 }: {
   chains: BusinessChain[];
+  /** 管理员：可管理任意链条（即使非本人）。 */
+  canManage: boolean;
   publishingId: string | null;
   onSettings: (c: BusinessChain) => void;
   onTogglePublic: (c: BusinessChain) => void;
@@ -919,7 +930,7 @@ function ChainTable({
           </thead>
           <tbody className="divide-y divide-zinc-100 text-xs text-zinc-800 dark:divide-[#1A2F5A] dark:text-[#C5CFE0]">
             {chains.map((chain) => {
-              const isMine = chain.isMine !== false;
+              const isMine = canManage || chain.isMine !== false;
               const ownerName = chain.ownerName ? chain.ownerName.split("@")[0] : "—";
               return (
                 <tr

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

@@ -0,0 +1,461 @@
+/**
+ * 「大屏绘制智能体」独立页面（带导航 + 侧边栏，挂在 StrategyRoutes 下）。
+ *
+ * 按外部 `taskId`（URL `?taskId=` / 路由 state / 登录暂存的任务详情 id）存取：
+ *   - 进入时按 taskId 拉取已存会话（`/api/dashboard-sessions/by-task`，**不按 user 分权**）。
+ *   - **已有有效结果（可解析的 report-json）** → 直接展示大屏页面（应用内 `DashboardApp`）。
+ *   - **没有有效结果** → 进入「生成过程」视图：自动让智能体分析登录拉取的业务 JSON
+ *     （现为占位适配，接口就绪后改后台转换 + 智能体校验）→ 边抽边在右侧沙箱显示，
+ *     **完成不自动跳**；底部输入框可随时改。
+ *   - 聊天记录 + 最新 report-json 防抖回存（按 taskId 共享，跨用户可见）。
+ *
+ * 数据抽取/聊天/沙箱/渲染全部复用 `useStep3Dashboard` + `DashboardChatPanel` +
+ * `DashboardApp`，仅把输入从「圆桌研讨成果」换成「任务原始 JSON」。
+ */
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { useLocation, useSearchParams } from "react-router-dom";
+import { toast } from "sonner";
+import {
+  ArrowLeft,
+  Boxes,
+  Code2,
+  ExternalLink,
+  LayoutPanelTop,
+  Loader2,
+  Pencil,
+  RefreshCw,
+  Sparkles,
+} from "lucide-react";
+
+import { fetchDashboardInputJson } from "@/core/auth/dashboard-input";
+import { readCopTaskDetail } from "@/core/auth/task-deeplink";
+import { desensitizeDeep } from "@/lib/desensitize";
+import { useModels } from "@/core/models/hooks";
+import { useTheme } from "@/contexts/ThemeContext";
+import { DashboardApp } from "@/roundtable-planning/dashboard/DashboardApp";
+import { adaptReportData } from "@/roundtable-planning/dashboard/data-context";
+import { DashboardChatPanel } from "@/roundtable-planning/components/DashboardChatPanel";
+import { Step2SandboxLayout } from "@/roundtable-planning/components/Step2SandboxLayout";
+import { DASHBOARD_VIEW_STORAGE_PREFIX } from "@/roundtable-planning/pages/DashboardStandalonePage";
+import { useStep3Dashboard } from "@/roundtable-planning/hooks/useStep3Dashboard";
+import type { Step2Dialogue } from "@/roundtable-planning/hooks/useStep2Orchestration";
+import {
+  buildDashboardPromptFromJson,
+  parseReportJson,
+  renderDashboardHtml,
+  type DashboardTheme,
+} from "@/roundtable-planning/lib/report-template";
+import {
+  getDashboardSessionByTask,
+  putDashboardSessionByTask,
+} from "@/roundtable-planning/api/dashboard-sessions";
+
+function formatNow(): string {
+  const d = new Date();
+  const pad = (n: number) => n.toString().padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+type DashView = "chat" | "page";
+type RenderMode = "app" | "html";
+
+/** 从 URL / 路由 state / 登录暂存任务详情解析 taskId。 */
+function useTaskId(): string {
+  const [searchParams] = useSearchParams();
+  const location = useLocation();
+  return useMemo(() => {
+    const fromQuery = searchParams.get("taskId")?.trim();
+    if (fromQuery) return fromQuery;
+    const fromState = (location.state as { taskId?: string } | null)?.taskId;
+    if (fromState && String(fromState).trim()) return String(fromState).trim();
+    const detail = readCopTaskDetail();
+    if (detail?.id != null && String(detail.id).trim()) return String(detail.id).trim();
+    return "";
+  }, [searchParams, location.state]);
+}
+
+export default function DashboardAgentPage() {
+  const taskId = useTaskId();
+  const { models: availableModels, isLoading: modelsLoading } = useModels();
+  const [selectedModel, setSelectedModel] = useState("");
+  const { theme } = useTheme();
+  const themeMode: DashboardTheme = theme === "dark" ? "dark" : "light";
+
+  // 输入 JSON（登录拉取/占位）——auto-start 时由 buildInitialPrompt 闭包读取。
+  const inputRef = useRef<unknown>(null);
+
+  const dashboard = useStep3Dashboard({
+    intentReady: null,
+    seatDeliveries: [],
+    consensusText: "",
+    selectedModel,
+    themeMode,
+    buildInitialPrompt: () => {
+      const inp = inputRef.current;
+      return inp ? buildDashboardPromptFromJson(inp) : null;
+    },
+  });
+
+  const {
+    phase,
+    dialogues,
+    data,
+    seatStubMessages,
+    activeArtifactThreadId,
+    busy,
+    redraw,
+    ask,
+    abort,
+    setPreviewEnabled,
+    openDashboardPreview,
+    start,
+    hydrateTranscript,
+  } = dashboard;
+
+  const [loading, setLoading] = useState(true);
+  const [view, setView] = useState<DashView>("chat");
+  const [renderMode, setRenderMode] = useState<RenderMode>("app");
+  // 真实接口请求失败/无数据时的提示（真实模式不拿假数据兜底，改为提示+重试）。
+  const [inputError, setInputError] = useState<string | null>(null);
+
+  // 默认选中第一个模型。
+  useEffect(() => {
+    if (availableModels.length === 0) return;
+    if (!availableModels.some((m) => m.name === selectedModel)) {
+      setSelectedModel(availableModels[0].name);
+    }
+  }, [availableModels, selectedModel]);
+
+  // init 只跑一次：start / hydrateTranscript 用 ref 持有，effect 只依赖 [taskId]。
+  // 否则它们的 identity 会随 selectedModel/themeMode 变化重建（模型挂载后异步加载即触发），
+  // 让 effect 在 await 期间 cleanup → 二次进入被 didInitRef 挡掉 → 首跑的 finally 因 cancelled
+  // 跳过 setLoading(false)，loading 永远停在 true（白转圈，卡在「正在加载任务大屏…」）。
+  const startRef = useRef(start);
+  startRef.current = start;
+  const hydrateTranscriptRef = useRef(hydrateTranscript);
+  hydrateTranscriptRef.current = hydrateTranscript;
+
+  // ── 挂载：按 taskId 取会话 → 决定直显大屏 / 看生成过程 ──
+  // 抽成可复用函数：首屏 effect 跑一次 + 「重试」按钮可再调（真实接口请求失败后重新拉取）。
+  const initialize = useCallback(async () => {
+    if (!taskId) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true); // 请求数据期间显示加载效果（「正在请求任务数据…」）
+    setInputError(null);
+    try {
+      // 会话 + 输入 JSON 并行取，但**都 await 完成后**才决定是否启动模型抽取——
+      // 即「先请求数据，待接口返回后再交给模型抽取」。输入写进 inputRef 供续问/重画复用。
+      const [session, input] = await Promise.all([
+        getDashboardSessionByTask(taskId).catch(() => null),
+        fetchDashboardInputJson(taskId).catch(() => null),
+      ]);
+      inputRef.current = input;
+      const savedDialogues = (session?.transcript as Step2Dialogue[] | undefined) ?? [];
+      const validReport = session?.reportJson && parseReportJson(session.reportJson);
+      if (validReport) {
+        // 有有效结果 → 恢复并直接展示大屏页面。
+        hydrateTranscriptRef.current(savedDialogues, session!.reportJson);
+        setView("page");
+      } else if (savedDialogues.length > 0) {
+        // 有历史聊天但无有效结果 → 进生成过程展示历史，不自动重跑（点「重新绘制」可重生成）。
+        hydrateTranscriptRef.current(savedDialogues, session?.reportJson ?? null);
+        setView("chat");
+      } else {
+        // 无任何记录 → 接口返回了真实数据才启动模型抽取；否则提示（真实模式不拿假数据兜底）。
+        setView("chat");
+        if (input) {
+          startRef.current();
+        } else {
+          setInputError("未获取到任务数据：接口请求失败或未返回内容，请稍后重试。");
+        }
+      }
+    } finally {
+      setLoading(false);
+    }
+    // 只依赖 taskId：start/hydrateTranscript 经 ref 读取，避免其 identity 变化重建本回调。
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [taskId]);
+
+  const didInitRef = useRef(false);
+  useEffect(() => {
+    if (didInitRef.current) return;
+    didInitRef.current = true;
+    void initialize();
+  }, [initialize]);
+
+  // ── 防抖回存聊天记录 + 最新 report-json（按 taskId 共享） ──
+  useEffect(() => {
+    if (!taskId || loading) return;
+    if (dialogues.length === 0) return;
+    const t = window.setTimeout(() => {
+      void putDashboardSessionByTask(taskId, {
+        transcript: dialogues,
+        reportJson: data ? JSON.stringify(data) : undefined,
+      }).catch(() => {
+        /* 回存失败不打扰用户 */
+      });
+    }, 800);
+    return () => window.clearTimeout(t);
+  }, [taskId, loading, dialogues, data]);
+
+  // 仅在交互区允许本流自动接管沙箱（并行流防抢）；离开/卸载时让出。
+  useEffect(() => {
+    setPreviewEnabled(view === "chat");
+    return () => setPreviewEnabled(false);
+  }, [view, setPreviewEnabled]);
+
+  // ── 大屏渲染数据（深度脱敏后渲染，覆盖大屏所有展示文本） ──
+  const report = useMemo(() => (data ? desensitizeDeep(data) : null), [data]);
+  const dashboardData = useMemo(
+    () => (report ? adaptReportData(report, formatNow()) : undefined),
+    [report],
+  );
+  const dashboardHtml = useMemo(
+    () => (report ? renderDashboardHtml(report, { generatedAt: formatNow(), theme: themeMode }) : null),
+    [report, themeMode],
+  );
+  const hasResult = !!dashboardData || !!dashboardHtml;
+
+  // 网页渲染：blob URL 作 iframe src（:target 导航需独立文档 URL，见 Step3DashboardMode 注释）。
+  const [htmlBlobUrl, setHtmlBlobUrl] = useState<string | null>(null);
+  useEffect(() => {
+    if (typeof window === "undefined" || !dashboardHtml) {
+      setHtmlBlobUrl(null);
+      return;
+    }
+    const url = URL.createObjectURL(new Blob([dashboardHtml], { type: "text/html;charset=utf-8" }));
+    setHtmlBlobUrl(url);
+    return () => URL.revokeObjectURL(url);
+  }, [dashboardHtml]);
+
+  const isStreaming =
+    phase === "creating" || phase === "streaming" || dialogues.some((d) => d.streaming === true);
+
+  // 「重新分析 / 修改」前都**重新请求一次最新数据**（数据可能已变化）；返回拉到的最新输入或 null。
+  const refreshInput = useCallback(async (): Promise<unknown | null> => {
+    if (!taskId) return null;
+    const fresh = await fetchDashboardInputJson(taskId, { forceRefresh: true }).catch(() => null);
+    if (fresh) inputRef.current = fresh; // 拉到才覆盖；失败保留上一次，避免清空可用数据
+    return fresh;
+  }, [taskId]);
+
+  // 防并发：刷新+生成进行中时再次点击直接忽略。
+  const refreshingRef = useRef(false);
+
+  // 重新生成/编辑统一闸门：**只有请求到最新数据才继续生成**，拿不到则提示并取消（不拿旧/空数据跑模型）。
+  const guardedGenerate = useCallback(
+    (run: () => void, cancelHint: string) => {
+      if (refreshingRef.current) return;
+      refreshingRef.current = true;
+      void (async () => {
+        const loadingId = toast.loading("正在请求最新任务数据…");
+        try {
+          const fresh = await refreshInput();
+          if (!fresh) {
+            toast.error(cancelHint, { id: loadingId });
+            return;
+          }
+          toast.dismiss(loadingId);
+          run();
+        } finally {
+          refreshingRef.current = false;
+        }
+      })();
+    },
+    [refreshInput],
+  );
+
+  const handleRedraw = useCallback(
+    () => guardedGenerate(redraw, "未获取到最新任务数据，已取消重新生成，请稍后重试"),
+    [guardedGenerate, redraw],
+  );
+
+  const handleAsk = useCallback(
+    (message: string) => guardedGenerate(() => ask(message), "未获取到最新任务数据，已取消修改，请稍后重试"),
+    [guardedGenerate, ask],
+  );
+
+  const handleOpenNewWindow = () => {
+    if (typeof window === "undefined") return;
+    if (renderMode === "html" && dashboardHtml) {
+      const blobUrl = URL.createObjectURL(new Blob([dashboardHtml], { type: "text/html;charset=utf-8" }));
+      window.open(blobUrl, "_blank", "noopener,noreferrer");
+      window.setTimeout(() => URL.revokeObjectURL(blobUrl), 60_000);
+      return;
+    }
+    const key = `${DASHBOARD_VIEW_STORAGE_PREFIX}${Date.now()}`;
+    try {
+      for (let i = window.localStorage.length - 1; i >= 0; i -= 1) {
+        const k = window.localStorage.key(i);
+        if (k && k.startsWith(DASHBOARD_VIEW_STORAGE_PREFIX)) window.localStorage.removeItem(k);
+      }
+      if (dashboardData) window.localStorage.setItem(key, JSON.stringify(dashboardData));
+    } catch {
+      /* localStorage 不可用：新窗口回落 DEMO */
+    }
+    const base = `${window.location.origin}${window.location.pathname}`;
+    window.open(`${base}#/roundtable-dashboard?k=${encodeURIComponent(key)}`, "_blank", "noopener,noreferrer");
+  };
+
+  if (!taskId) {
+    return (
+      <div className="flex h-full min-h-0 items-center justify-center p-8 text-center text-sm text-slate-500">
+        <div>
+          <Sparkles className="mx-auto mb-3 h-8 w-8 text-primary/40" />
+          缺少任务标识（taskId）。请通过带 <code className="px-1">?taskId=</code> 的链接进入大屏绘制页。
+        </div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="flex h-full min-h-0 flex-col text-slate-800 dark:text-slate-200">
+      {/* 顶栏 */}
+      <div className="dashboard-agent-topbar shrink-0 flex flex-wrap items-center justify-between gap-3 border-b border-slate-100 bg-gradient-to-r from-slate-50 to-white px-6 py-3">
+        <div className="flex items-center gap-2.5">
+          <Sparkles className="h-4.5 w-4.5 text-primary" />
+          <h3 className="text-sm font-black tracking-tight text-slate-900">大屏绘制智能体</h3>
+          <span className="inline-flex items-center gap-1.5 rounded-full border border-red-200/50 bg-[var(--brand-200)]/60 px-2 py-0.5 text-[10px] font-bold text-primary">
+            {(phase === "creating" || phase === "streaming") && <Loader2 className="h-3 w-3 animate-spin" />}
+            {view === "chat" ? "生成过程" : "大屏页面"}
+          </span>
+        </div>
+
+        <div className="flex items-center gap-2">
+          {view === "page" ? (
+            <>
+              <div className="inline-flex items-center gap-0.5 rounded-xl border border-slate-200 bg-slate-50 p-0.5">
+                <button
+                  type="button"
+                  onClick={() => setRenderMode("app")}
+                  title="用应用内 React 组件渲染（Tab 切换、动画、席位钻取）"
+                  className={`flex items-center gap-1 rounded-lg px-2.5 py-1 text-[10.5px] font-bold transition ${
+                    renderMode === "app"
+                      ? "border border-slate-200 bg-white text-primary shadow-sm"
+                      : "text-slate-500 hover:text-slate-700"
+                  }`}
+                >
+                  <Boxes className="h-3.5 w-3.5" />
+                  应用渲染
+                </button>
+                <button
+                  type="button"
+                  onClick={() => setRenderMode("html")}
+                  disabled={!dashboardHtml}
+                  title={dashboardHtml ? "用自包含 HTML 大屏渲染（与新窗口/下载一致）" : "尚无已生成的 HTML，先完成一次绘制"}
+                  className={`flex items-center gap-1 rounded-lg px-2.5 py-1 text-[10.5px] font-bold transition disabled:cursor-not-allowed disabled:opacity-40 ${
+                    renderMode === "html"
+                      ? "border border-slate-200 bg-white text-primary shadow-sm"
+                      : "text-slate-500 hover:text-slate-700"
+                  }`}
+                >
+                  <Code2 className="h-3.5 w-3.5" />
+                  网页渲染
+                </button>
+              </div>
+              <button
+                type="button"
+                onClick={() => setView("chat")}
+                title="回到生成过程，加载聊天记录继续问答修改"
+                className="flex items-center gap-1 rounded-xl border border-slate-200 bg-white px-3 py-1.5 text-[10.5px] font-bold text-slate-700 transition hover:bg-slate-50"
+              >
+                <Pencil className="h-3.5 w-3.5 text-slate-500" />
+                编辑
+              </button>
+              <button
+                type="button"
+                onClick={handleOpenNewWindow}
+                title={renderMode === "html" ? "新标签页打开自包含 HTML 大屏" : "新标签页打开应用内 React 大屏（全屏）"}
+                className="flex items-center gap-1 rounded-xl border border-slate-200 bg-white px-3 py-1.5 text-[10.5px] font-bold text-slate-700 transition hover:bg-slate-50"
+              >
+                <ExternalLink className="h-3.5 w-3.5 text-slate-500" />
+                新窗口打开
+              </button>
+            </>
+          ) : (
+            hasResult && (
+              <button
+                type="button"
+                onClick={() => setView("page")}
+                title="查看已生成的大屏页面"
+                className="flex items-center gap-1 rounded-xl border border-slate-200 bg-white px-3 py-1.5 text-[10.5px] font-bold text-slate-700 transition hover:bg-slate-50"
+              >
+                <LayoutPanelTop className="h-3.5 w-3.5 text-slate-500" />
+                查看大屏
+              </button>
+            )
+          )}
+        </div>
+      </div>
+
+      {/* 主体 */}
+      {loading ? (
+        <div className="flex flex-1 flex-col items-center justify-center gap-3 text-sm text-slate-500">
+          <Loader2 className="h-6 w-6 animate-spin text-primary" />
+          <div className="text-center">
+            <div className="font-semibold text-slate-700">正在请求任务数据…</div>
+            <div className="mt-1 text-xs text-slate-400">拉取接口返回后将自动开始智能体抽取绘制</div>
+          </div>
+        </div>
+      ) : inputError && dialogues.length === 0 ? (
+        <div className="flex flex-1 items-center justify-center p-8 text-center text-sm text-slate-500">
+          <div className="max-w-sm">
+            <Sparkles className="mx-auto mb-3 h-8 w-8 text-primary/40" />
+            <div className="mb-4 text-slate-600">{inputError}</div>
+            <button
+              type="button"
+              onClick={() => void initialize()}
+              className="inline-flex items-center gap-1.5 rounded-xl border border-slate-200 bg-white px-4 py-2 text-xs font-bold text-slate-700 transition hover:bg-slate-50"
+            >
+              <RefreshCw className="h-3.5 w-3.5 text-slate-500" />
+              重新请求
+            </button>
+          </div>
+        </div>
+      ) : view === "page" ? (
+        renderMode === "html" && htmlBlobUrl ? (
+          <iframe
+            title="任务研讨大屏"
+            src={htmlBlobUrl}
+            className="min-h-0 w-full flex-1 border-0 bg-white"
+            sandbox="allow-scripts allow-popups allow-downloads allow-same-origin"
+          />
+        ) : (
+          <div className="min-h-0 flex-1 overflow-auto">
+            <DashboardApp data={dashboardData} />
+          </div>
+        )
+      ) : (
+        <div className="min-h-0 flex-1 p-3">
+          <section className="h-full min-h-0 overflow-hidden rounded-2xl border border-slate-200/60 bg-white">
+            <Step2SandboxLayout
+              activeThreadId={activeArtifactThreadId}
+              isStreaming={isStreaming}
+              seatMessages={activeArtifactThreadId ? seatStubMessages[activeArtifactThreadId] : undefined}
+            >
+              <DashboardChatPanel
+                phase={phase}
+                dialogues={dialogues}
+                busy={busy}
+                error={dashboard.error}
+                onAsk={handleAsk}
+                onRedraw={handleRedraw}
+                onPause={abort}
+                onOpenPreview={openDashboardPreview}
+                hasResult={hasResult}
+                selectedModel={selectedModel}
+                availableModels={availableModels}
+                modelsLoading={modelsLoading}
+                setSelectedModel={setSelectedModel}
+                subtitle="分析任务原始数据，提炼为大屏结构化数据（右侧实时显示抽取过程）"
+                doneHint="数据已就绪，点右上「查看大屏」查看。"
+              />
+            </Step2SandboxLayout>
+          </section>
+        </div>
+      )}
+    </div>
+  );
+}