diff --git a/.project-docs/30-worklog/tasks/20261012-agent-chat-composer-42b8f6d1.md b/.project-docs/30-worklog/tasks/20261012-agent-chat-composer-42b8f6d1.md
new file mode 100644
index 00000000..3efed82f
--- /dev/null
+++ b/.project-docs/30-worklog/tasks/20261012-agent-chat-composer-42b8f6d1.md
@@ -0,0 +1,76 @@
+# Task: Simplify Agent chat and add attachment composer
+
+## Identity
+
+- Task ID: 20261012-agent-chat-composer-42b8f6d1
+- Mode: Feature
+- Branch: codex/20261012-agent-chat-composer-42b8f6d1-agent-chat-composer
+- Worktree: /Users/chillishark/Makelore 麦洛/.codex-worktrees/makelore/20261012-agent-chat-composer-42b8f6d1
+- Base commit: 7af43acebb5d8b118fa16c838dfba2f18e535bb1
+- Owner: codex
+- Status: Implementing
+
+## Scope
+
+- Simplify personal Agent chat into read-only Agent identity, transcript and attachment composer. Remove configuration/save/apply controls, source tabs, toolbar title/billing/version copy and history/new-chat icons from the published conversation. Add inline pending attachments and user bubbles using the existing Makelore visual system. Integrate committed thinking increment from ad1d2f2→4160119 without reverting the current chat/composer/layout. Shrink own Agent list cards to about two-thirds of their former desktop dimensions, retaining usable controls. Update the currently logged-in temporary application with this and inherited Agent/channel changes.
+
+## Intent And Constraints
+
+- User explicitly authorizes UI implementation and temporary-app refresh; product language throughout. Configuration remains editable from cards; chat identity is read-only because save/apply controls are removed there. Retain published/preview request identities, recovery, Run/approval/cancellation, existing history and creator billing semantics. Files use Main-owned upload/confirm operations, removal from the composer deselects rather than deleting cloud data. No live model calls, user-file uploads or WeChat operations for verification.
+- Isolated feature writes only own source/tests/README/task record and new ignored runtime stage. Prior approved channel/sidebar/config/chat ancestry retained. Do not copy uncommitted peer source or change auth/profile/Main/runtime contract as incidental UI work.
+
+## Project Context Loaded
+
+Task context:
+- Task: 20261012-agent-chat-composer-42b8f6d1, Feature, owner codex.
+- Worktree: /Users/chillishark/Makelore 麦洛/.codex-worktrees/makelore/20261012-agent-chat-composer-42b8f6d1.
+- Branch: codex/20261012-agent-chat-composer-42b8f6d1-agent-chat-composer.
+- Base/HEAD at gate: 7af43acebb5d8b118fa16c838dfba2f18e535bb1. Bundled check/start/status passed and exact registry identity independently checked.
+- 40 peer records read only: 39 specific, one old undefined child-language record. No blocked semantic dependency. At the original gate thinking task 20261012-cloud-agent-thinking-76a89e3d remained planning without a deliverable; a later explicit delegation now supplies committed 416011943ea306fa0336d044c8a328e500034c01 and requests its thinking-only increment from ad1d2f2. Commit and record read; semantic three-way integration preserves this task’s layout, attachments and generation guards. No uncommitted peer source read/copied.
+
+Read:
+- AGENTS, read-before-planning, memory index, own record, positioning/current integrated snapshot, decision index, system overview/community collaboration, domain/success criteria, personal-cloud-agent ADR, evidence/reflection/commitment indexes. Large integrated historical snapshots read with targeted current/relevant sections; historical UI descriptions defer to this explicit user direction.
+- CloudChat, DraftEditor, CloudFiles, local chat CSS, typed attachment APIs and Main upload boundary; focused unit and Electron specs. Design skill search reviewed, adapting only accessible progressive disclosure to existing cream/pastel/orange palette, not its suggested new font/pink/motion scheme.
+
+Relevant understanding:
+- Client supports students/creators and personal Agents; no courses. Main owns network/auth/upload, Yuxi owns cloud requests/history and WS owns billing. Removing visible billing/version copy does not alter payment or execution.
+- User wants a calm conversation page without configuration/management toolbars; the list card remains the configuration entry. Preserve loaded conversation and approvals while simplifying presentation. Image/file picking uses the existing native upload boundary; do not fake image URLs or bypass Host API.
+- Current temporary Main PID63739/Host62867, bootstrap Entry Trial, renderer from verified WeChat task d823ddb. New stage must explicitly understand its live dist symlink and preserve the prior renderer for rollback. Final source clean commit/build/Main byte checks plus actual visible CUA verification required.
+- Likely files: DraftEditor, CloudChat/local CSS, new attachment-composer component, focused checks/README/own record. Canonical docs read-only, feature promotion proposals only. No unresolved product conflict.
+
+Gate result:
+- Passed.
+
+## Plan
+
+1. Separate chat identity from configuration controls, remove source/management toolbar from published chat while retaining preview-only maintenance behavior used elsewhere.
+2. Integrate file/image picking, pending file cards and safe per-message removal inside the composer; user messages use distinct rounded bubbles. Keep loading/errors/running/approval and safe send/retry behavior.
+3. Run relevant unit, typecheck/scoped lint/build and production Electron checks at large/compact sizes. Commit the clean reviewed result, refresh the known trial renderer with rollback and verify the visible updated conversation; record actual evidence and limits.
+
+## Outcome
+
+- Published chat has read-only saved identity and return control. Configuration status/actions, source tabs, routine billing/version title and published history/new-chat controls are removed; card adjustment entry and explicit save/apply behavior remain.
+- User messages use lilac bubbles. The composer directly adds native-picked files/images, shows pending cards and deselects without deleting. Remote confirmation failures preserve uploaded object/thread/method for explicit retry. Pending confirmation blocks sending; attachment-only input uses the explicit query “请看看这些附件。”. No fabricated image URL contract or new Main endpoint.
+- Preview maintenance controls retain safe behavior; attachment createThread late responses cannot change a newer Agent/thread. Requests, version binding, history recovery, approval and stop boundaries remain.
+- Home cards measured at 1440px from 386.7×323.5 to 256×221 (66.2% width, 68.3% height); 48px avatar and 44px operation targets, no transform scaling. Narrow windows adapt, longer descriptions clamp to two lines.
+- Committed thinking-only increment from ad1d2f2→4160119 integrated without older layout changes. Separate reasoning block, exact Run/main-thread filtering, replay deduplication and bounded final-history hydration preserved. Added explicit execution epoch for same-Run approval continuation and guarded late approval callbacks; no cross-view overwrites. Durable history depends on the Yuxi API patch not yet deployed.
+- Temporary application refresh pending clean source binding and background activation. Native activation/clicks stopped after latest no-focus direction; visible reload will be handed to the user.
+
+## Verification
+
+- Pinned pnpm typecheck passed; scoped source/test lint passed with two pre-existing CloudChat warnings (export/cleanup-ref), no errors. git diff --check passed.
+- Delegated relevant page/start-use/workflow tests: 61 passed. Attachment component tests: 14 passed. Root ran entry-navigation/avatar/guidance/management: 28 passed.
+- Browser layout fixtures: 10 passed at 375/768/1024/1440, long Markdown independently scrolls; inline image-type cards, deselection, approval and stop verified. Root viewed desktop inline attachment and compact bubble screenshots; adjusted compact send alignment to right.
+- Card fixture measurements and screenshots inspected at 375/768/1024/1440, no overflow or operation wrapping, long/empty introduction handled.
+- Final combined production Vite renderer/Main/preload/utility compile passed. Combined reasoning/stream tests: 14 passed including same-Run continuation and late approval replies; combined workflows 21 passed, headless layout 12 passed (includes two reasoning scenarios). Root viewed compact live reasoning screenshot and confirmed readable content/composer.
+- Before the added no-focus constraint, the production Electron identity/configuration/chat spec passed; the old channel spec failed because it still required the intentionally removed WeChat conversation tab. That spec was adapted to current binding UI and linted, but the combined reasoning and adapted channel Electron specs were not rerun because the fixture launches a visible window. This limit is explicit; no production/backend/real-provider claims. No actual uploads, model calls or WeChat mutations performed.
+- Read-only native observation after the no-focus direction showed the known logged-in trial on its Agent list with no pending editor/composer. No activation, desktop click or credential/profile read.
+
+## Follow-ups
+
+- None recorded.
+
+## Promotion Candidates
+
+- Update current personal Agent presentation documentation at integration: published conversation contains identity/transcript/composer only, pending attachments are per-message deselection, recent history continues automatically; home cards use compact 256px desktop width.
+- Thinking-only increment of committed 4160119 is now integrated; history recovery depends on Yuxi committed 7b16aef deployment by its owner. No production deployment performed; current stage requires final combined verification. User requests no desktop focus capture during the remaining verification/update; native UI actions are paused and renderer update must stay background.
diff --git a/README.md b/README.md
index aae8ad06..90ed57eb 100644
--- a/README.md
+++ b/README.md
@@ -12,7 +12,7 @@ Makelore 是一个面向软件、视觉创作、智能机器人与个人云智
 
 - `Makelore Code｜AI 编程`：管理本地项目、项目智能体、对话、文件上下文、代码变更和运行时。
   会话工作台采用浅蓝项目栏、彩色通用手柄图标与卡片选中态；中间对话/作品使用圆角标签，作品预览的后退、前进、刷新与网址输入统一放在标签右侧；只在作品页显示，窄窗口自动换行。右侧智能体咨询使用奶油色标题区。沿用真实项目和会话入口、侧栏伸缩与账户菜单，样式只作用于 Code 会话工作台。可编辑的空对话在输入区上方的可用区域中央显示童趣欢迎语；「去作品广场逛逛」入口紧贴输入框上方，两者一起位于底部。老师介绍以固定宽度浮在右上角，不占用中间布局；欢迎语和底部输入区始终相对项目栏右侧的整个内容区域居中；小窗口的欢迎内容独立滚动；发送首条消息后收起欢迎区。侧栏保留「作品广场」入口，只有点击后才在系统浏览器打开公共广场，不请求、摘取或内嵌展示广场作品。打开广场保留当前项目、对话、草稿和附件，不自动发送消息；老师求助按钮保留临时应用的最新文案「帮我整体看🧠」。
-- `Makelore Agents｜AI 智能体`：从模块首页进入时先打开“我的智能体”卡片列表，保留此前对话与操作恢复记录；返回首页箭头与侧栏折叠按钮同排，折叠后仍可返回；智能体模块的侧栏只通过按钮点击或键盘激活展开，鼠标经过左侧、收纳按钮或顶栏不会展开，切换模块不沿用旧悬停预览；其他模块仍保留原预览方式。“我的智能体”使用浅紫对话机器人图标，“渠道”使用浅蓝连接节点图标。macOS 原生窗口按钮留出安全空间。首页围绕自己的智能体和创建入口，显示童趣问候“Hi，今天想创造还是想聊聊？”，不再显示更多、收到的分享、活动或归档筛选。卡片显示名称、可为空的一句话介绍及状态，支持聊天、调整、继续制作和确认删除；删除沿用云端归档机制，移出列表并停用新调用，历史和费用保留。创建先填写名称并选择平台像素头像或上传头像，下一步进入独立配置。顶部名称有编辑图标，头像可点击修改；未设置头像时使用同一张默认像素头像，从创建到配置、改名、保存和重新打开保持一致。基础页为“介绍与提示词”，一句话介绍可留空，完整提示词保留原始文本；模型作为高级设置第一项必选，未选择时不能开始使用，草稿可分步保存，不自动选模型。介绍与提示词采用浅蓝介绍卡和浅紫提示词卡；高级设置按模型、工具箱（Tool）、做事手册（Skill）、MCP 服务、子智能体和知识库纵向呈现，不再设内部分类切换；不展示 Tool/Skill 解释、资源开放规则提示、云端能力管理、费用上限或运行限制卡片，保存其他配置时保留既有运行限制，费用规则不变。顶层页签切换保留搜索、资源选择、知识表单及未保存输入。配置页移除聊天、自动任务和使用与接入导航，独立聊天仍从卡片进入，微信账号仍在侧栏渠道管理。草稿明确保存（Ctrl/⌘+S）；保存只更新草稿，“应用最新修改”使新配置生效，失败重试保持原操作身份；点击“开始使用”完成必要的私有启用后直接打开聊天，不再展示二次确认页；未保存修改、缺少模型、冲突或尚未确认的请求会留在配置页处理，打开聊天不自动发送消息。独立对话沿用奶油底色和浅蓝、浅紫、薄荷色：空对话展示当前智能体头像与名称，示例只填入草稿；用户消息和智能体回复区分呈现，长 Markdown、表格和代码在消息区内滚动，底部输入框、附件、停止和历史入口保留；短窗口中，配置完全生效且没有待处理问题时收起重复的已保存／已应用提示和禁用按钮，修改或待确认时恢复；“调整智能体”与客户端／微信来源同排，窄窗口会换行，未发送内容的离开保护不变。头像上传、Main-owned Host API、访问隔离、费用与不可变版本规则保持；介绍留空需要配套 Yuxi DraftCreate/DraftSave 的空字符串契约。
+- `Makelore Agents｜AI 智能体`：从模块首页进入时先打开“我的智能体”卡片列表，保留此前对话与操作恢复记录；返回首页箭头与侧栏折叠按钮同排，折叠后仍可返回；智能体模块的侧栏只通过按钮点击或键盘激活展开，鼠标经过左侧、收纳按钮或顶栏不会展开，切换模块不沿用旧悬停预览；其他模块仍保留原预览方式。“我的智能体”使用浅紫对话机器人图标，“渠道”使用浅蓝连接节点图标。macOS 原生窗口按钮留出安全空间。首页围绕自己的智能体和创建入口，显示童趣问候“Hi，今天想创造还是想聊聊？”，不再显示更多、收到的分享、活动或归档筛选。卡片采用更紧凑的尺寸与留白，显示名称、可为空的一句话介绍及状态，支持聊天、调整、继续制作和确认删除；删除沿用云端归档机制，移出列表并停用新调用，历史和费用保留。创建先填写名称并选择平台像素头像或上传头像，下一步进入独立配置。顶部名称有编辑图标，头像可点击修改；未设置头像时使用同一张默认像素头像，从创建到配置、改名、保存和重新打开保持一致。基础页为“介绍与提示词”，一句话介绍可留空，完整提示词保留原始文本；模型作为高级设置第一项必选，未选择时不能开始使用，草稿可分步保存，不自动选模型。介绍与提示词采用浅蓝介绍卡和浅紫提示词卡；高级设置按模型、工具箱（Tool）、做事手册（Skill）、MCP 服务、子智能体和知识库纵向呈现，不再设内部分类切换；不展示 Tool/Skill 解释、资源开放规则提示、云端能力管理、费用上限或运行限制卡片，保存其他配置时保留既有运行限制，费用规则不变。顶层页签切换保留搜索、资源选择、知识表单及未保存输入。配置页移除聊天、自动任务和使用与接入导航，独立聊天仍从卡片进入，微信账号仍在侧栏渠道管理。草稿明确保存（Ctrl/⌘+S）；保存只更新草稿，“应用最新修改”使新配置生效，失败重试保持原操作身份；点击“开始使用”完成必要的私有启用后直接打开聊天，不再展示二次确认页；未保存修改、缺少模型、冲突或尚未确认的请求会留在配置页处理，打开聊天不自动发送消息。独立对话沿用奶油底色和浅蓝、浅紫、薄荷色：顶部只展示返回、只读头像和名称，不展示调整、保存／应用状态、客户端／微信来源、费用／版本说明或历史／新对话图标；配置由列表卡片的“调整”进入。空对话展示当前智能体头像与名称，示例只填入草稿；用户消息使用浅紫圆角气泡，助手 Markdown、表格和代码在消息区内滚动。文件或图片从输入框内添加，上传成功后以待发送卡片呈现，可移除本次携带；移除不会删除云端文件，添加不会自动发送。确认失败沿用同一文件和对话重试，发送前需完成或取消添加；支持仅发送附件，使用明确的附件提问。对话文件按需展开查看和选择，生成文件仍可下载；最近对话自动恢复、审批、停止和未发送内容的离开保护保留。模型返回的思考独立于正文展示，运行时可展开、手动折叠，完成后折叠；无思考内容时不显示。重连事件去重并隔离当前运行与主对话，终态历史未到达时保留已收到的片段并有限补读；服务端返回的最终回答思考可在历史中回看，不进入后续提问。历史回看需要 Yuxi API 思考投影补丁上线，当前未部署；实时思考沿用既有事件流。头像上传、Main-owned Host API、访问隔离、费用与不可变版本规则保持；介绍留空需要配套 Yuxi DraftCreate/DraftSave 的空字符串契约。
 
   云知识库的 embedding 模型只由平台管理员在 Yuxi 后台维护：在「智能体管理 → 模型供应商」启用供应商，按供应商要求填写有效的服务地址和 API Key，添加并启用 embedding 模型并填写实际向量维度；embedding 向量化费用由平台承担，不计入用户用量、词元点数或智能体费用上限；one-api 不参与 embedding 配置，Works Square 只负责其他应计费模型调用的创建者词元点数账本。客户端区分目录加载中、加载失败与无可用模型，空状态提供管理员配置说明；「刷新知识库与模型」保留未提交名称，未确认的创建请求沿用原操作身份。
 
diff --git a/shared/cloud-agents.ts b/shared/cloud-agents.ts
index 52d50e7d..b9bd84ae 100644
--- a/shared/cloud-agents.ts
+++ b/shared/cloud-agents.ts
@@ -98,6 +98,7 @@ export interface CloudInterrupt {
 export interface CloudMessage {
   id: number; role: 'user' | 'assistant' | 'system'; content: string; request_id: string;
   run_id: string | null; created_at: string;
+  reasoning_content?: string;
 }
 export interface CloudHistory {
   thread_id: string; messages: CloudMessage[]; run: CloudRun | null; next_offset: number | null;
diff --git a/src/pages/CloudAgents/CloudChat.tsx b/src/pages/CloudAgents/CloudChat.tsx
index 2003ee3b..028dc000 100644
--- a/src/pages/CloudAgents/CloudChat.tsx
+++ b/src/pages/CloudAgents/CloudChat.tsx
@@ -4,7 +4,7 @@ import { Button } from '@/components/ui/button';
 import { Textarea } from '@/components/ui/textarea';
 import { cloudAgentsApi } from '@/lib/cloud-agents-api';
 import type { CloudHistory, CloudInterrupt, CloudPrompt, CloudRequest, CloudRun, CloudThread, CloudScheduleProposal } from '../../../shared/cloud-agents';
-import { CloudFiles } from './CloudFiles';
+import { CloudComposerAttachments } from './CloudComposerAttachments';
 import { CloudAvatar } from './CloudAvatar';
 import './desktop-workspace.css';
 import './agent-chat.css';
@@ -12,6 +12,7 @@ import ReactMarkdown, { defaultUrlTransform } from 'react-markdown';
 import remarkGfm from 'remark-gfm';
 import { CloudPendingContext, useCloudPendingState, usePendingCloudInput } from './CloudPending';
 import { agentExamples } from './agent-guidance';
+import { consumeCloudChatEvent, type CloudChatStream } from './cloud-chat-stream';
 
 export const cloudStatus = (status: string) => ({
   idle: '尚未开始', queued: '等待执行', dispatching: '准备执行', dispatched: '已提交', pending: '准备中',
@@ -41,12 +42,19 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
   const [intent, setIntent] = useState<CloudPrompt | null>(null);
   const [busy, setBusy] = useState(false);
   const [error, setError] = useState('');
-  const [liveText, setLiveText] = useState('');
+  const [liveReply, setLiveReply] = useState<CloudChatStream | null>(null);
+  const streamReply = useRef<CloudChatStream | null>(null);
+  const updateLiveReply = useCallback((next: CloudChatStream | null) => {
+    streamReply.current = next;
+    setLiveReply(next);
+  }, []);
   const [progress, setProgress] = useState('');
   const [interrupt, setInterrupt] = useState<CloudInterrupt | null>(null);
   const [loading, setLoading] = useState(true);
   const [leaving, setLeaving] = useState(false);
   const [attachmentIds, setAttachmentIds] = useState<string[]>([]);
+  const [attachmentBusy, setAttachmentBusy] = useState(false);
+  const [executionEpoch, setExecutionEpoch] = useState(0);
   const childrenPending = useCloudPendingState();
   usePendingCloudInput(busy || Boolean(intent) || Boolean(query.trim()) || attachmentIds.length > 0 || childrenPending.hasPending);
   const generation = useRef(0);
@@ -63,11 +71,16 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
     }
     if (!alive.current || expectedGeneration !== generation.current) return;
     setHistory(page); setRun(page.run); setInterrupt(page.run?.interrupt ?? null);
+    // Replace the preview only after authoritative assistant history arrives.
+    // Failed/cancelled Runs without a saved answer retain received fragments.
+    const preview = streamReply.current;
+    if (preview?.threadId === id && page.run?.agent_run_id === preview.runId && !active(page.run.status)
+      && page.messages.some(item => item.role === 'assistant' && item.run_id === preview.runId)) updateLiveReply(null);
     setQueued(page.queued_requests ?? []);
     setRequest(active(page.run?.status) ? null : page.queued_requests?.[0] ?? null);
     if (page.run) setThreads(current => current.map(item => item.thread_id === id
       ? { ...item, run_id: page.run!.agent_run_id, status: !active(page.run!.status) && page.queued_requests?.length ? 'queued' : page.run!.status, unread: false } : item));
-  }, []);
+  }, [updateLiveReply]);
   useEffect(() => {
     alive.current = true;
     const g = ++generation.current;
@@ -149,7 +162,7 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
       });
     }, 2000);
     return () => window.clearInterval(timer);
-  }, [queued.length, thread, readHistory]);
+  }, [queued.length, thread, readHistory, executionEpoch]);
 
   const runId = request && active(request.status) ? request.run_id ?? undefined : run?.agent_run_id;
   const running = active(run?.status) || active(request?.status);
@@ -162,25 +175,26 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
       if (!live || g !== generation.current) return;
       try {
         const envelope = object(JSON.parse(event.data));
-        const payload = object(envelope.payload);
-        const chunk = object(payload.chunk);
         const targetThread = thread?.thread_id ?? request?.thread_id;
-        if (envelope.thread_id && targetThread && envelope.thread_id !== targetThread) return;
-        for (const item of Array.isArray(payload.items) ? payload.items : [chunk]) {
-          const semantic = object(object(item).stream_event);
-          if (semantic.type === 'message_delta' && typeof semantic.content === 'string') setLiveText(v => v + semantic.content);
-          if (semantic.type === 'tool_call' && typeof semantic.name === 'string') setProgress('正在使用 ' + semantic.name);
-        }
+        if (!targetThread) return;
+        const targetRequest = request?.request_id ?? run?.request_id;
+        const next = consumeCloudChatEvent(streamReply.current, envelope, event.type, event.lastEventId, runId, targetThread, targetRequest);
+        if (next !== streamReply.current) updateLiveReply(next);
+        if (envelope.run_id !== runId || envelope.thread_id !== targetThread
+          || targetRequest && envelope.request_id && envelope.request_id !== targetRequest) return;
+        const chunk = object(object(envelope.payload).chunk);
+        if (next?.toolName) setProgress('正在使用 ' + next.toolName);
         if (event.type === 'interrupt') setInterrupt(chunk as CloudInterrupt);
         if (event.type === 'end') {
           source?.close();
-          setLiveText(''); setProgress('');
+          setProgress('');
           const id = thread?.thread_id ?? request?.thread_id;
           if (id) void readHistory(id, g).catch(e => { if (live) setError(message(e)); });
         }
       } catch { setError('运行事件读取失败，正在重新读取状态'); }
     };
-    cloudAgentsApi.events(runId).then(stream => {
+    const cursor = streamReply.current?.runId === runId ? streamReply.current.cursor : '0-0';
+    (cursor === '0-0' ? cloudAgentsApi.events(runId) : cloudAgentsApi.events(runId, cursor)).then(stream => {
       if (!live) { stream.close(); return; }
       source = stream;
       for (const name of ['metadata', 'messages', 'custom', 'interrupt', 'end']) stream.addEventListener(name, accept as EventListener);
@@ -193,14 +207,39 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
         if (!live || g !== generation.current) return;
         setRun(next);
         if (!active(next.status)) {
-          source?.close(); setLiveText(''); setProgress(''); setInterrupt(next.interrupt ?? null);
+          source?.close(); setProgress(''); setInterrupt(next.interrupt ?? null);
           void readHistory(next.thread_id, g).catch(e => { if (live) setError(message(e)); });
         }
       }).catch(e => { if (live) setError(message(e)); });
     }, 5000);
     return () => { live = false; source?.close(); window.clearInterval(timer); };
-  }, [runId, running, thread?.thread_id, request?.thread_id, readHistory]);
-  useEffect(() => { if (following.current && transcript.current) transcript.current.scrollTop = transcript.current.scrollHeight; }, [history?.messages.length, liveText, interrupt]);
+  }, [runId, running, thread?.thread_id, request?.thread_id, request?.request_id, run?.request_id, readHistory, updateLiveReply, executionEpoch]);
+  // Run settlement can arrive before its final message is persisted. Keep
+  // hydration independent of the running-state poll, and never replay a prompt.
+  const previewRunId = liveReply?.runId;
+  const previewThreadId = liveReply?.threadId;
+  const previewEnded = liveReply?.ended;
+  const currentRunId = run?.agent_run_id;
+  const currentRunStatus = run?.status;
+  useEffect(() => {
+    if (!previewRunId || !previewThreadId || currentRunId && (currentRunId !== previewRunId || currentRunStatus === 'interrupted')
+      || !previewEnded && running) return;
+    let live = true;
+    let attempts = 0;
+    let timer: number;
+    const g = generation.current;
+    const id = previewThreadId;
+    const refresh = async () => {
+      if (!live || g !== generation.current) return;
+      attempts++;
+      try { await readHistory(id, g); }
+      catch (error) { if (live && g === generation.current) setError(message(error)); }
+      if (live && g === generation.current && attempts < 10) timer = window.setTimeout(() => void refresh(), 2000);
+    };
+    timer = window.setTimeout(() => void refresh(), 2000);
+    return () => { live = false; window.clearTimeout(timer); };
+  }, [previewRunId, previewThreadId, previewEnded, currentRunId, currentRunStatus, running, readHistory, executionEpoch]);
+  useEffect(() => { if (following.current && transcript.current) transcript.current.scrollTop = transcript.current.scrollHeight; }, [history?.messages.length, liveReply, interrupt]);
   const stalePreview = previewRevision !== undefined && latestRevision !== undefined && previewRevision !== latestRevision;
 
   const rememberThread = (next: CloudThread) => {
@@ -208,19 +247,21 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
     setThreads(current => [next, ...current.filter(item => item.thread_id !== next.thread_id)]);
   };
   const send = async () => {
-    if (busy || running || thread?.archived || (!intent && (hasUnsavedChanges || stalePreview || !previewReady || !query.trim()))) return;
+    if (busy || attachmentBusy || childrenPending.hasPending || running || thread?.archived || (!intent && (hasUnsavedChanges || stalePreview || !previewReady || (!query.trim() && !attachmentIds.length)))) return;
     const input = intent ?? {
-      request_id: crypto.randomUUID(), thread_id: thread?.thread_id ?? clientId, query: query.trim(),
-      attachment_file_ids: attachmentIds,
+      request_id: crypto.randomUUID(), thread_id: thread?.thread_id ?? clientId, query: query.trim() || '请看看这些附件。',
+      attachment_file_ids: [...attachmentIds],
       ...(previewRevision === undefined ? {} : { expected_revision: previewRevision }),
     };
     following.current = true;
     setBusy(true); setIntent(input); setError('');
-    const g = generation.current;
+    let g = generation.current;
     try {
       const accepted = await cloudAgentsApi.call(previewRevision === undefined ? 'submit' : 'preview', { slug, ...input });
       if (!alive.current || g !== generation.current) return;
-      setRequest(accepted); setIntent(null); setQuery(''); setLiveText(''); setAttachmentIds([]);
+      g = ++generation.current;
+      setExecutionEpoch(value => value + 1);
+      setRequest(accepted); setIntent(null); setQuery(''); updateLiveReply(null); setProgress(''); setAttachmentIds([]);
       rememberThread({ thread_id: accepted.thread_id, client_thread_id: clientId, agent_slug: slug, title: input.query.slice(0, 80),
         mode, draft_revision: previewRevision, updated_at: new Date().toISOString(), run_id: accepted.run_id, status: accepted.status, unread: false });
       await readHistory(accepted.thread_id, g);
@@ -233,7 +274,7 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
     if (mode === 'preview') setPreviewRevision(next?.draft_revision ?? revision);
     const g = ++generation.current;
     setThread(next); setClientId(next?.client_thread_id ?? crypto.randomUUID()); setHistory(null);
-    setRequest(null); setQueued([]); setRun(null); setLiveText(''); setInterrupt(null); setError(''); if (!keepQuery) setQuery('');
+    setRequest(null); setQueued([]); setRun(null); updateLiveReply(null); setProgress(''); setInterrupt(null); setError(''); if (!keepQuery) setQuery('');
     setAttachmentIds([]);
     if (next) { setLoading(true); try { await readHistory(next.thread_id, g); } catch(e) { setError(message(e)); } finally { setLoading(false); } }
   };
@@ -258,13 +299,14 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
       else if (runId) await cloudAgentsApi.call('cancelRun', { run_id: runId });
     } catch (e) { setError(message(e)); } finally { setBusy(false); }
   };
+  const approvalGeneration = generation.current;
   return <CloudPendingContext.Provider value={childrenPending.report}><section className="agent-chat agent-chat-styled" aria-label={previewRevision === undefined ? '智能体对话' : '草稿预览'}>
-    <div className="agent-chat-toolbar"><div className="agent-chat-toolbar-row">
+    {mode === 'preview' && <div className="agent-chat-toolbar"><div className="agent-chat-toolbar-row">
       <div className="agent-chat-toolbar-heading"><span className="agent-chat-toolbar-icon" aria-hidden="true"><MessageCircle /></span><div className="min-w-0"><p className="agent-chat-toolbar-title">{previewRevision === undefined ? '和助手聊一聊' : '试一试'}</p>
         {previewRevision !== undefined && <p className="mt-1 text-xs text-muted-foreground">当前试用 · 修订 {previewRevision}</p>}
         <p className="mt-1 text-xs text-muted-foreground">由创建者支付词元点数{run?.version && ` · 版本 ${run.version}`}</p></div></div>
       <div className="agent-chat-toolbar-actions"><Button variant="ghost" aria-label="查看历史对话" title="查看历史对话" aria-expanded={showHistory} onClick={() => setShowHistory(v => !v)}><History aria-hidden="true" className="h-4 w-4" /><span>历史对话</span></Button>
-      <Button variant="ghost" disabled={busy || Boolean(intent) || loading} onClick={() => (query.trim() || attachmentIds.length > 0 || childrenPending.hasPending) ? setLeaving(true) : void choose(null)} aria-label="新对话"><MessageSquarePlus aria-hidden="true" className="h-4 w-4" /><span>新对话</span></Button>{headerAction}</div>
+      <Button variant="ghost" disabled={busy || attachmentBusy || Boolean(intent) || loading} onClick={() => (query.trim() || attachmentIds.length > 0 || childrenPending.hasPending) ? setLeaving(true) : void choose(null)} aria-label="新对话"><MessageSquarePlus aria-hidden="true" className="h-4 w-4" /><span>新对话</span></Button>{headerAction}</div>
     </div>
     {showHistory && threads.length === 0 && <p className="py-2 text-xs text-muted-foreground">还没有历史对话</p>}
     {showHistory && threads.length > 0 && <select aria-label="历史对话" className="agent-chat-history-select"
@@ -278,11 +320,11 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
       {trialPending && <p className="text-xs text-muted-foreground">先完成当前试用或确认操作，并取消附件选择，再重新试用。</p>}
       {!previewReady && <p className="text-muted-foreground">当前草稿尚未选择模型。选择模型并保存后，可开始新试用。</p>}
     </div>}
-    </div>
+    </div>}
     <div ref={transcript} data-testid="cloud-chat-messages" className="agent-chat-scroll"
       onScroll={e => { const el = e.currentTarget; following.current = el.scrollHeight - el.scrollTop - el.clientHeight < 64; }}><div className="agent-chat-transcript">
       {loading ? <div role="status" className="agent-chat-loading"><MessageCircle aria-hidden="true" /><p>正在读取对话…</p></div>
-        : !history?.messages.length && !liveText && <div className="agent-chat-welcome">
+        : !history?.messages.length && !liveReply?.content && !liveReply?.reasoning && <div className="agent-chat-welcome">
           <div className="agent-chat-welcome-portrait"><CloudAvatar src={assistantAvatarUrl} name={assistantName} className="agent-chat-welcome-avatar" /><Sparkles aria-hidden="true" className="agent-chat-welcome-spark" /></div>
           <p className="agent-chat-welcome-name">{assistantName}</p>
           <h2>{mode === 'preview' ? '问它一个小问题' : 'Hi，今天想聊些什么？'}</h2>
@@ -298,9 +340,11 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
         <TrialMessages history={previousTrial.history} onError={setError} assistantName={assistantName} assistantAvatarUrl={assistantAvatarUrl} />
       </details>}
       {history && <TrialMessages history={history} onError={setError} assistantName={assistantName} assistantAvatarUrl={assistantAvatarUrl} />}
-      {liveText && <article className="agent-chat-message" data-role="assistant" aria-label="助手正在回复">
+      {liveReply && (liveReply.content || liveReply.reasoning) && <article className="agent-chat-message" data-role="assistant" aria-label="助手正在回复">
         <CloudAvatar src={assistantAvatarUrl} name={assistantName} className="agent-chat-message-avatar" />
-        <div className="agent-chat-message-content"><p className="agent-chat-speaker">{assistantName}</p><div className="agent-chat-message-body whitespace-pre-wrap">{liveText}</div></div>
+        <div className="agent-chat-message-content"><p className="agent-chat-speaker">{assistantName}</p>
+          {liveReply.reasoning && <CloudReasoning content={liveReply.reasoning} running={running && runId === liveReply.runId && !liveReply.ended} />}
+          {liveReply.content && <div className="agent-chat-message-body whitespace-pre-wrap">{liveReply.content}</div>}</div>
       </article>}
       {onSchedule && history?.schedule_proposals?.map(proposal => <article key={proposal.id} className="space-y-3 rounded-xl border border-violet-200 bg-violet-50/30 p-4 text-sm">
         <h3 className="font-medium">自动任务建议 · {proposal.name}</h3><p className="whitespace-pre-wrap">{proposal.prompt}</p>
@@ -309,7 +353,12 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
       </article>)}
       {run?.error && run.status === 'failed' && <p role="alert" className="text-sm text-destructive">{run.error.message}</p>}
       {interrupt && runId && !thread?.archived && <CloudApproval key={runId} interrupt={interrupt} runId={runId} onResumed={nextRun => {
-        setInterrupt(null); setLiveText(''); setRun(nextRun); setRequest(null);
+        if (!alive.current || approvalGeneration !== generation.current) return;
+        generation.current++;
+        setExecutionEpoch(value => value + 1);
+        const preview = streamReply.current;
+        if (preview?.runId === nextRun.agent_run_id) updateLiveReply({ ...preview, ended: false });
+        setInterrupt(null); setProgress(''); setRun(nextRun); setRequest(null);
       }} />}
 
     {queued.length > 0 && <div className="mb-3 space-y-2 rounded-lg bg-muted/40 p-3 text-sm">
@@ -333,25 +382,28 @@ export function CloudChat({ slug, previewRevision: latestRevision, initialThread
       }}>恢复对话</Button>
     </div>}
     </div></div>
-    <div className="agent-chat-files"><CloudFiles key={clientId} threadId={thread?.thread_id} selected={attachmentIds} onSelected={setAttachmentIds}
-      onBusy={setBusy} disabled={busy || running || Boolean(intent) || loading || Boolean(thread?.archived)} ensureThread={async () => {
-        if (thread) return thread.thread_id;
-        const created = await cloudAgentsApi.call('createThread', { slug, thread_id: clientId, preview: previewRevision !== undefined, expected_revision: previewRevision });
-        rememberThread({ thread_id: created.thread_id, client_thread_id: clientId, agent_slug: slug, title: '新对话', mode, draft_revision: previewRevision,
-          status: 'idle', updated_at: new Date().toISOString(), run_id: null, unread: false });
-        return created.thread_id;
-      }} /></div>
     {leaving && <div className="mb-3 flex flex-wrap items-center gap-2 text-sm"><span>放弃未发送的内容并新建对话？</span>
       <Button variant="outline" onClick={() => { setLeaving(false); void choose(null); }}>放弃内容</Button><Button variant="ghost" onClick={() => setLeaving(false)}>继续编辑</Button></div>}
     <form data-testid="cloud-chat-composer" className="agent-chat-composer" onSubmit={e => { e.preventDefault(); void send(); }}>
+      <CloudComposerAttachments key={clientId} threadId={thread?.thread_id} selected={attachmentIds} onSelected={setAttachmentIds}
+        onBusy={setAttachmentBusy} disabled={busy || running || Boolean(intent) || loading || Boolean(thread?.archived)} ensureThread={async () => {
+          if (thread) return thread.thread_id;
+          const expectedGeneration = generation.current;
+          const created = await cloudAgentsApi.call('createThread', { slug, thread_id: clientId, preview: previewRevision !== undefined, expected_revision: previewRevision });
+          if (!alive.current || expectedGeneration !== generation.current) return created.thread_id;
+          rememberThread({ thread_id: created.thread_id, client_thread_id: clientId, agent_slug: slug, title: '新对话', mode, draft_revision: previewRevision,
+            status: 'idle', updated_at: new Date().toISOString(), run_id: null, unread: false });
+          return created.thread_id;
+        }} footer={<>
+          <span className="agent-chat-keyboard-hint">Enter 发送 · Shift + Enter 换行</span>
+          {running ? <Button className="agent-chat-stop" size="sm" variant="outline" disabled={busy} onClick={() => void cancel()} type="button" aria-label="停止回答"><Square className="h-4 w-4" /></Button>
+            : <Button className="agent-chat-send" size="icon" type="submit" aria-label={busy ? '正在提交' : intent ? '重试本次发送' : '发送'} title={intent ? '重试本次发送' : '发送'} disabled={busy || attachmentBusy || childrenPending.hasPending || loading || thread?.archived || (!intent && (hasUnsavedChanges || stalePreview || !previewReady || (!query.trim() && !attachmentIds.length)))}><Send className="h-4 w-4" /></Button>}
+        </>}>
       <Textarea aria-label="消息" className="agent-chat-input resize-y border-0 shadow-none focus-visible:ring-0" maxLength={32000}
         value={query} disabled={busy || Boolean(intent) || loading || thread?.archived} placeholder="说说你的想法，或问一个问题…" onChange={e => setQuery(e.target.value)}
         onKeyDown={e => { if (e.key === 'Enter' && !e.shiftKey && !e.nativeEvent.isComposing && e.keyCode !== 229) { e.preventDefault(); void send(); } }} />
-      <div className="agent-chat-composer-footer">
-        <div className="agent-chat-composer-meta"><p role="status" className="agent-chat-status" data-active={running}>{progress || (running ? cloudStatus(run?.status ?? request?.status ?? '') : run ? cloudStatus(run.status) : '就绪')}</p><span className="agent-chat-keyboard-hint">Enter 发送 · Shift + Enter 换行</span></div>
-        {running ? <Button className="agent-chat-stop" size="sm" variant="outline" disabled={busy} onClick={() => void cancel()} type="button"><Square className="mr-2 h-3 w-3" />停止</Button>
-          : <Button className="agent-chat-send" size="sm" type="submit" disabled={busy || loading || thread?.archived || (!intent && (hasUnsavedChanges || stalePreview || !previewReady || !query.trim()))}><Send className="mr-2 h-3 w-3" />{busy ? '正在提交…' : intent ? '重试本次发送' : '发送'}</Button>}
-      </div>
+      {(running || progress) && <p role="status" className="agent-chat-status" data-active={running}>{progress || cloudStatus(run?.status ?? request?.status ?? '')}</p>}
+      </CloudComposerAttachments>
     </form>
   </section></CloudPendingContext.Provider>;
 }
@@ -361,15 +413,27 @@ function TrialMessages({ history, onError, assistantName = '助手', assistantAv
 }) {
   return history.messages.map(item => <article key={item.id} className="agent-chat-message" data-role={item.role === 'user' ? 'user' : 'assistant'}>
     {item.role !== 'user' && <CloudAvatar src={assistantAvatarUrl} name={assistantName} className="agent-chat-message-avatar" />}
-    <div className="agent-chat-message-content"><p className="agent-chat-speaker">{item.role === 'user' ? '你' : assistantName}</p>
-    <div className="agent-chat-message-body prose prose-sm max-w-none break-words"><ReactMarkdown urlTransform={url => url.startsWith('sandbox:/') ? url.slice(8) : defaultUrlTransform(url)} remarkPlugins={[remarkGfm]} components={{
+    <div className="agent-chat-message-content">{item.role !== 'user' && <p className="agent-chat-speaker">{assistantName}</p>}
+    {item.role === 'assistant' && typeof item.reasoning_content === 'string' && item.reasoning_content
+      && <CloudReasoning content={item.reasoning_content} running={false} />}
+    <div className="agent-chat-message-body prose prose-sm max-w-none break-words">{item.role === 'user' ? <p className="whitespace-pre-wrap">{item.content}</p> : <ReactMarkdown urlTransform={url => url.startsWith('sandbox:/') ? url.slice(8) : defaultUrlTransform(url)} remarkPlugins={[remarkGfm]} components={{
       a: ({ href, children }) => href && !/^(https?:|mailto:|#)/i.test(href)
         ? <button className="text-primary underline" onClick={() => void cloudAgentsApi.download(history.thread_id, href.replace(/^\/api\/chat\/thread\/[^/]+\/artifacts\//, '/')).catch(e => onError(message(e)))}>{children}</button>
         : <a href={href} target="_blank" rel="noreferrer">{children}</a>,
-    }}>{item.content}</ReactMarkdown></div></div>
+    }}>{item.content}</ReactMarkdown>}</div></div>
   </article>);
 }
 
+function CloudReasoning({ content, running }: { content: string; running: boolean }) {
+  const [expanded, setExpanded] = useState(running);
+  useEffect(() => { setExpanded(running); }, [running]);
+  return <details open={expanded} onToggle={event => setExpanded(event.currentTarget.open)}
+    className="agent-chat-reasoning" data-testid="cloud-chat-reasoning">
+    <summary>思考过程</summary>
+    <div aria-label="智能体思考过程" className="agent-chat-reasoning-content">{content}</div>
+  </details>;
+}
+
 export function CloudApproval({ interrupt, runId, onResumed, submitDecision }: {
   interrupt: CloudInterrupt; runId: string; onResumed?: (run: CloudRun) => void;
   submitDecision?: (input: { operation_id: string; decision: Record<string, unknown> }) => Promise<void>;
diff --git a/src/pages/CloudAgents/CloudComposerAttachments.tsx b/src/pages/CloudAgents/CloudComposerAttachments.tsx
new file mode 100644
index 00000000..aaef07ad
--- /dev/null
+++ b/src/pages/CloudAgents/CloudComposerAttachments.tsx
@@ -0,0 +1,224 @@
+import { useEffect, useId, useRef, useState, type ReactNode } from 'react';
+import { ChevronDown, Download, FileText, Folder, Image, Plus, X } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { cloudAgentsApi } from '@/lib/cloud-agents-api';
+import { usePendingCloudInput } from './CloudPending';
+import type { CloudAttachment, CloudFile, CloudUpload } from '../../../shared/cloud-agents';
+
+type PendingUpload = {
+  upload: CloudUpload;
+  threadId?: string;
+  method: string;
+  parsedObjectName?: string;
+  chooseMethod: boolean;
+  locked: boolean;
+};
+
+type AttachmentList = { threadId?: string; items: CloudAttachment[]; error: string };
+type FileList = { threadId?: string; path: string; items: CloudFile[]; error: string };
+
+function message(error: unknown) {
+  return error instanceof Error ? error.message : '文件操作失败，请重试。';
+}
+
+function isImage(name: string) {
+  return /\.(avif|bmp|gif|heic|heif|ico|jpe?g|png|svg|tiff?|webp)$/iu.test(name);
+}
+
+function fileSize(size: number) {
+  if (size < 1024) return size + ' B';
+  if (size < 1024 * 1024) return Math.ceil(size / 1024) + ' KB';
+  return (size / (1024 * 1024)).toFixed(1) + ' MB';
+}
+
+function mergeAttachments(...lists: CloudAttachment[][]) {
+  return [...new Map(lists.flat().map(file => [file.file_id, file])).values()];
+}
+
+export function CloudComposerAttachments({ threadId, ensureThread, selected, onSelected, onBusy, disabled, children, footer }: {
+  threadId?: string;
+  ensureThread: () => Promise<string>;
+  selected: string[];
+  onSelected: (ids: string[]) => void;
+  onBusy: (busy: boolean) => void;
+  disabled: boolean;
+  children?: ReactNode;
+  footer?: ReactNode;
+}) {
+  const [attachmentList, setAttachmentList] = useState<AttachmentList>({ items: [], error: '' });
+  const [fileList, setFileList] = useState<FileList>({ path: '/', items: [], error: '' });
+  const [localThreadId, setLocalThreadId] = useState<string>();
+  const [pending, setPending] = useState<PendingUpload | null>(null);
+  const [busy, setBusy] = useState(false);
+  const [error, setError] = useState('');
+  const [pickerFailed, setPickerFailed] = useState(false);
+  const [open, setOpen] = useState(false);
+  const [path, setPath] = useState('/');
+  const [refresh, setRefresh] = useState(0);
+  const mounted = useRef(false);
+  const busyRef = useRef(false);
+  const confirmed = useRef(new Map<string, CloudAttachment[]>());
+  const callbacks = useRef({ onBusy, onSelected, selected });
+  const libraryId = useId();
+  const currentThreadId = threadId ?? localThreadId;
+  const attachments = attachmentList.threadId === currentThreadId ? attachmentList.items : [];
+  const knownFiles = attachments;
+  const blocked = disabled || busy;
+  const attachmentsLoading = Boolean(currentThreadId) && attachmentList.threadId !== currentThreadId;
+  const filesLoading = Boolean(currentThreadId) && (fileList.threadId !== currentThreadId || fileList.path !== path);
+  usePendingCloudInput(busy || Boolean(pending));
+
+  useEffect(() => { callbacks.current = { onBusy, onSelected, selected }; }, [onBusy, onSelected, selected]);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      if (busyRef.current) {
+        busyRef.current = false;
+        callbacks.current.onBusy(false);
+      }
+    };
+  }, []);
+
+  useEffect(() => {
+    if (!currentThreadId) return;
+    let live = true;
+    cloudAgentsApi.call('attachments', { thread_id: currentThreadId }).then(result => {
+      if (live) setAttachmentList({ threadId: currentThreadId, items: mergeAttachments(result.attachments, confirmed.current.get(currentThreadId) ?? []), error: '' });
+    }).catch(error => {
+      if (live) setAttachmentList({ threadId: currentThreadId, items: confirmed.current.get(currentThreadId) ?? [], error: message(error) });
+    });
+    return () => { live = false; };
+  }, [currentThreadId, refresh]);
+
+  useEffect(() => {
+    if (!open || !currentThreadId) return;
+    let live = true;
+    cloudAgentsApi.call('files', { thread_id: currentThreadId, path }).then(result => {
+      if (live) setFileList({ threadId: currentThreadId, path, items: result.files, error: '' });
+    }).catch(error => {
+      if (live) setFileList({ threadId: currentThreadId, path, items: [], error: message(error) });
+    });
+    return () => { live = false; };
+  }, [open, currentThreadId, path, refresh]);
+
+  async function act(task: () => Promise<void>) {
+    if (disabled || busyRef.current || !mounted.current) return;
+    busyRef.current = true;
+    setBusy(true); setError(''); callbacks.current.onBusy(true);
+    try { await task(); }
+    catch (error) { if (mounted.current) setError(message(error)); }
+    finally {
+      if (mounted.current) {
+        busyRef.current = false;
+        setBusy(false); callbacks.current.onBusy(false);
+      }
+    }
+  }
+
+  async function confirm(attempt: PendingUpload) {
+    // Freeze the file, reading method and resolved thread before a remote confirmation.
+    // A lost response can then be retried without picking or creating anything again.
+    const upload = { ...attempt, locked: true };
+    setPending({ ...upload });
+    if (!upload.threadId) {
+      const id = await ensureThread();
+      if (!mounted.current) return;
+      upload.threadId = id;
+      setLocalThreadId(id); setPending({ ...upload });
+    }
+    if (upload.method !== 'disable' && !upload.parsedObjectName) {
+      const parsed = await cloudAgentsApi.call('parseAttachment', { object_name: upload.upload.object_name, parse_method: upload.method });
+      if (!mounted.current) return;
+      if (!parsed.parsed_object_name) throw new Error('文件读取没有完成，请重试。');
+      upload.parsedObjectName = parsed.parsed_object_name;
+      setPending({ ...upload });
+    }
+    const result = await cloudAgentsApi.call('confirmAttachment', { thread_id: upload.threadId, attachments: [{
+      object_name: upload.upload.object_name,
+      file_type: upload.upload.file_type,
+      ...(upload.parsedObjectName ? { parsed_object_name: upload.parsedObjectName } : {}),
+    }] });
+    if (!mounted.current) return;
+    if (!result.attachments.length) throw new Error('文件暂未加入，请重试。');
+    const all = mergeAttachments(confirmed.current.get(upload.threadId) ?? [], result.attachments);
+    confirmed.current.set(upload.threadId, all);
+    setAttachmentList(previous => ({ threadId: upload.threadId, items: mergeAttachments(previous.threadId === upload.threadId ? previous.items : [], all), error: previous.threadId === upload.threadId ? previous.error : '' }));
+    callbacks.current.onSelected([...new Set([...callbacks.current.selected, ...result.attachments.map(file => file.file_id)])]);
+    setPending(null); setRefresh(value => value + 1);
+  }
+
+  function pick(chooseMethod = false) {
+    if (pending) return;
+    void act(async () => {
+      setPickerFailed(false);
+      let picked: CloudUpload | null;
+      try { picked = await cloudAgentsApi.upload(); }
+      catch (error) { if (mounted.current) setPickerFailed(true); throw error; }
+      if (!mounted.current || !picked) return;
+      const upload: PendingUpload = { upload: picked, threadId: currentThreadId, method: 'disable', chooseMethod, locked: false };
+      setPending(upload);
+      if (!chooseMethod || !picked.parse_supported) await confirm(upload);
+    });
+  }
+
+  function choose(fileId: string, value: boolean) {
+    if (disabled || busyRef.current) return;
+    const current = callbacks.current.selected;
+    callbacks.current.onSelected(value ? [...new Set([...current, fileId])] : current.filter(id => id !== fileId));
+  }
+
+  return <div className="agent-attachment-composer">
+    {selected.length > 0 && <div className="agent-attachment-selected" aria-label="本条消息的附件">
+      {selected.map(id => {
+        const file = knownFiles.find(file => file.file_id === id);
+        const name = file?.file_name ?? '已选文件';
+        const image = isImage(name);
+        const Icon = image ? Image : FileText;
+        return <div key={id} className="agent-attachment-card" data-kind={image ? 'image' : 'file'}>
+          <span className="agent-attachment-icon"><Icon aria-label={image ? '图片文件' : '文件'} size={22} /></span>
+          <div className="agent-attachment-card-info"><span className="agent-attachment-name" title={name}>{name}</span><span className="agent-attachment-size">{file ? fileSize(file.file_size) : '已选择'}</span></div>
+          <Button type="button" variant="ghost" size="icon" className="agent-attachment-remove" disabled={blocked} aria-label={'移除附件 ' + name} onClick={() => choose(id, false)}><X size={15} /></Button>
+        </div>;
+      })}
+    </div>}
+    {children}
+    {pending && <div className="agent-attachment-pending">
+      <span className="agent-attachment-name" title={pending.upload.file_name}>{pending.upload.file_name}</span>
+      {busy ? <span role="status">正在加入附件…</span> : <>
+        {pending.chooseMethod && pending.upload.parse_supported && <label className="agent-attachment-reading">读取方式<select aria-label="附件读取方式" value={pending.method} disabled={disabled || pending.locked} onChange={event => setPending({ ...pending, method: event.target.value })}>
+          <option value="disable">保留原始文件</option>{pending.upload.parse_methods.filter(method => method !== 'disable').map(method => <option key={method} value={method}>{method === 'rapid_ocr' ? '本地文字识别' : method}</option>)}
+        </select></label>}
+        <Button type="button" variant="outline" size="sm" disabled={disabled} onClick={() => void act(() => confirm(pending))}>{error ? '重试添加' : '添加到消息'}</Button>
+        <Button type="button" variant="ghost" size="sm" disabled={disabled} onClick={() => { setPending(null); setError(''); }}>取消添加</Button>
+      </>}
+    </div>}
+    {error && <div className="agent-attachment-error"><p role="alert">{error}</p>{pickerFailed && <>
+      <Button type="button" variant="ghost" size="sm" disabled={blocked} onClick={() => pick()}>重试选择文件</Button>
+      <Button type="button" variant="ghost" size="sm" disabled={blocked} onClick={() => { setPickerFailed(false); setError(''); }}>取消添加</Button>
+    </>}</div>}
+    <div className="agent-attachment-toolbar">
+      <div className="agent-attachment-actions">
+        <Button type="button" variant="ghost" size="sm" className="agent-attachment-add" disabled={blocked || Boolean(pending)} onClick={() => pick()}><Plus size={18} />添加文件或图片</Button>
+        <Button type="button" variant="ghost" size="sm" className="agent-attachment-browse" aria-expanded={open} aria-controls={libraryId} onClick={() => setOpen(value => !value)}><ChevronDown size={16} />对话文件</Button>
+      </div>
+      {footer}
+    </div>
+    {open && <div id={libraryId} className="agent-attachment-library">
+      <div className="agent-attachment-library-header"><span>已上传的文件</span><Button type="button" variant="ghost" size="sm" disabled={busy} onClick={() => setRefresh(value => value + 1)}>刷新文件</Button></div>
+      {attachmentsLoading ? <p role="status">正在读取文件…</p> : attachmentList.threadId === currentThreadId && attachmentList.error ? <p role="alert">{attachmentList.error}</p> : knownFiles.length === 0 && <p className="agent-attachment-empty">还没有上传文件。</p>}
+      {knownFiles.map(file => {
+        const Icon = isImage(file.file_name) ? Image : FileText;
+        return <label key={file.file_id} className="agent-attachment-library-file"><input type="checkbox" aria-label={'选择附件 ' + file.file_name} checked={selected.includes(file.file_id)} disabled={blocked} onChange={event => choose(file.file_id, event.target.checked)} /><Icon size={18} /><span className="agent-attachment-name" title={file.file_name}>{file.file_name}</span><span className="agent-attachment-size">{fileSize(file.file_size)}</span></label>;
+      })}
+      <Button type="button" variant="ghost" size="sm" className="agent-attachment-reading-add" disabled={blocked || Boolean(pending)} onClick={() => pick(true)}>添加并选择读取方式</Button>
+      {currentThreadId && <div className="agent-attachment-artifacts">
+        <div className="agent-attachment-library-header"><span className="agent-attachment-path" title={path}>对话产物 · {path}</span>{path !== '/' && <Button type="button" variant="ghost" size="sm" disabled={busy} onClick={() => setPath(path.split('/').slice(0, -1).join('/') || '/')}>上一级</Button>}</div>
+        {filesLoading ? <p role="status">正在读取产物…</p> : fileList.error ? <p role="alert">{fileList.error}</p> : fileList.items.length === 0 && <p className="agent-attachment-empty">还没有生成文件。</p>}
+        {!filesLoading && fileList.items.map(file => <div key={file.path} className="agent-attachment-library-file">
+          {file.is_dir ? <Button type="button" variant="ghost" className="agent-attachment-directory" disabled={busy} onClick={() => setPath(file.directory_path)}><Folder size={18} /><span className="agent-attachment-name" title={file.name}>{file.name}</span></Button> : <><FileText size={18} /><span className="agent-attachment-name" title={file.name}>{file.name}</span><span className="agent-attachment-size">{fileSize(file.size)}</span><Button type="button" variant="ghost" size="icon" disabled={blocked} aria-label={'保存 ' + file.name} onClick={() => void act(async () => { await cloudAgentsApi.download(currentThreadId, file.path); })}><Download size={17} /></Button></>}
+        </div>)}
+      </div>}
+    </div>}
+  </div>;
+}
diff --git a/src/pages/CloudAgents/DraftEditor.tsx b/src/pages/CloudAgents/DraftEditor.tsx
index d4c8a804..45524875 100644
--- a/src/pages/CloudAgents/DraftEditor.tsx
+++ b/src/pages/CloudAgents/DraftEditor.tsx
@@ -9,7 +9,6 @@ import { cloudAgentsApi } from '@/lib/cloud-agents-api';
 import { EMPTY_CLOUD_CONFIGURATION, type CloudAgentDraft, type CloudRecent } from '../../../shared/cloud-agents';
 import { ConfigurationFields } from './ConfigurationFields';
 import { CloudChat } from './CloudChat';
-import { CloudChannelConversations } from './CloudChannelConversations';
 import { CloudPendingContext, useCloudPendingState } from './CloudPending';
 import { AgentRequirements } from './AgentRequirements';
 import { CloudAvatar, CloudAvatarEditor } from './CloudAvatar';
@@ -39,8 +38,6 @@ export function DraftEditor({ initial, recent, onBack, onSaved, startingPrompt,
   const initialTab = entryView ?? (recent?.mode === 'preview' ? 'configuration' : initial.published_version ? 'chat' : 'configuration');
   const [tab, setTab] = useState<Tab>(initialTab);
   const [visited, setVisited] = useState<Set<Tab>>(() => new Set([initialTab]));
-  const [conversationSource, setConversationSource] = useState<'desktop' | 'wechat'>('desktop');
-  const [wechatVisited, setWechatVisited] = useState(false);
   const pending = useCloudPendingState();
   const formalPending = useCloudPendingState();
   const alive = useRef(true);
@@ -118,7 +115,7 @@ export function DraftEditor({ initial, recent, onBack, onSaved, startingPrompt,
   };
   useEffect(() => {
     const shortcut = (event: KeyboardEvent) => {
-      if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 's') { event.preventDefault(); void save(); }
+      if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === 's') { event.preventDefault(); if (tab === 'configuration') void save(); }
     };
     window.addEventListener('keydown', shortcut);
     return () => window.removeEventListener('keydown', shortcut);
@@ -127,8 +124,12 @@ export function DraftEditor({ initial, recent, onBack, onSaved, startingPrompt,
   return <CloudPendingContext.Provider value={pending.report}><section className={`agent-desktop${tab === 'chat' ? ' agent-chat-editor' : ''}`} data-testid="cloud-agent-editor"
     data-configuration-settled={!dirty && !busy && !publication.pending && !publication.error && !remote && publication.appliedRevision === saved.draft_revision}>
     <header className={`agent-workspace-header${tab === 'chat' ? ' agent-chat-workspace-header' : ''}`}>
-      <Button variant="ghost" size="icon" className="h-10 w-10 shrink-0" aria-label="我的智能体" disabled={busy}
+      <Button variant="ghost" size="icon" className="h-10 w-10 shrink-0" aria-label={tab === 'chat' ? '返回智能体列表' : '我的智能体'} disabled={busy}
         onClick={() => dirty || hasPending ? setLeaving(true) : onBack()}><ArrowLeft className="h-4 w-4" /></Button>
+      {tab === 'chat' ? <>
+        <CloudAvatar src={saved.icon_url} name={saved.name} identity={saved.slug} className="agent-chat-header-avatar" />
+        <h2 className="agent-chat-header-name">{saved.name}</h2>
+      </> : <>
       <Button variant="ghost" className="agent-chat-identity-avatar relative h-12 w-12 shrink-0 p-0" aria-label="修改头像" title="修改头像" disabled={busy} onClick={() => setEditingAvatar(true)}>
         <CloudAvatar src={draft.icon_url} name={draft.name} identity={saved.slug} />
         <span className="absolute -bottom-1 -right-1 rounded-full border-2 border-background bg-primary p-1 text-white"><ImagePlus aria-hidden="true" className="h-3 w-3" /></span>
@@ -157,12 +158,13 @@ export function DraftEditor({ initial, recent, onBack, onSaved, startingPrompt,
         {publication.busy && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
         {publication.busy ? '正在开始…' : publication.pending ? '重试开始使用' : '开始使用'}
       </Button>}
+      </>}
     </header>
-    {saved.published_version && (needsApply || dirty) && <div className="shrink-0 border-b border-amber-200 bg-amber-50 px-6 py-3 text-sm text-amber-900">
+    {tab === 'configuration' && saved.published_version && (needsApply || dirty) && <div className="shrink-0 border-b border-amber-200 bg-amber-50 px-6 py-3 text-sm text-amber-900">
       <p className="font-medium">{dirty ? '修改尚未保存和应用' : '这次修改还没有应用到正在使用的助手'}</p>
       <p className="mt-1 text-xs leading-5">保存只更新草稿。请点击顶部“应用最新修改”，再到微信等渠道使用。已开始的任务保持原配置。</p>
     </div>}
-    {publication.error && <p role="alert" className="shrink-0 px-6 py-2 text-sm text-destructive">{publication.error} <Button variant="ghost" disabled={busy} onClick={() => void publication.refresh()}>刷新应用状态</Button></p>}
+    {tab === 'configuration' && publication.error && <p role="alert" className="shrink-0 px-6 py-2 text-sm text-destructive">{publication.error} <Button variant="ghost" disabled={busy} onClick={() => void publication.refresh()}>刷新应用状态</Button></p>}
     {error && <p role="alert" className="shrink-0 px-6 py-2 text-sm text-destructive">{error}</p>}
     {remote && <div className="max-h-52 shrink-0 space-y-2 overflow-auto border-b border-amber-200 bg-amber-50 px-6 py-3 text-sm">
       <p className="font-medium">云端已有修订 {remote.draft_revision}，本地输入仍保留</p>
@@ -200,21 +202,7 @@ export function DraftEditor({ initial, recent, onBack, onSaved, startingPrompt,
     </div>
     <div hidden={tab !== 'chat'} className="agent-workspace-view agent-conversation-workspace">
       {visited.has('chat') && <CloudPendingContext.Provider value={formalPending.report}>
-        <nav aria-label="对话来源" className="agent-conversation-sources">
-          {saved.published_version && <div className="agent-conversation-source-options">
-            <Button variant={conversationSource === 'desktop' ? 'secondary' : 'ghost'} aria-pressed={conversationSource === 'desktop'} disabled={formalPending.hasPending && conversationSource !== 'desktop'} onClick={() => setConversationSource('desktop')}>客户端对话</Button>
-            <Button variant={conversationSource === 'wechat' ? 'secondary' : 'ghost'} aria-pressed={conversationSource === 'wechat'} disabled={formalPending.hasPending && conversationSource !== 'wechat'} onClick={() => { setWechatVisited(true); setConversationSource('wechat'); }}>微信对话</Button>
-          </div>}
-          <Button variant="ghost" className="agent-conversation-adjust" onClick={() => {
-            if (formalPending.hasPending) { setError('对话中还有未完成的内容，请先发送或处理后再调整智能体。'); return; }
-            setError(''); navigate('configuration');
-          }}><Pencil aria-hidden="true" className="mr-2 h-4 w-4" />调整智能体</Button>
-        </nav>
-        {saved.published_version ? <>
-        <div hidden={conversationSource !== 'desktop'} className="flex min-h-0 flex-1 flex-col">
-          <CloudChat key="published" slug={saved.slug} assistantName={saved.name} assistantAvatarUrl={saved.icon_url} activeView={tab === 'chat' && conversationSource === 'desktop'} /></div>
-        <div hidden={conversationSource !== 'wechat'} className="min-h-0 flex-1 overflow-auto">{wechatVisited && <CloudChannelConversations slug={saved.slug} activeView={tab === 'chat' && conversationSource === 'wechat'} />}</div>
-        </>
+        {saved.published_version ? <CloudChat key="published" slug={saved.slug} assistantName={saved.name} assistantAvatarUrl={saved.icon_url} activeView={tab === 'chat'} />
         : <div className="m-auto space-y-4 text-center text-sm"><p>保存配置后，开始使用这个智能体。</p><Button disabled={busy || remote !== null || !publication.access} onClick={startUsing}>{publication.pending ? '重试开始使用' : '开始使用'}</Button></div>}
       </CloudPendingContext.Provider>}
     </div>
diff --git a/src/pages/CloudAgents/agent-chat.css b/src/pages/CloudAgents/agent-chat.css
index a89c3750..ac33d490 100644
--- a/src/pages/CloudAgents/agent-chat.css
+++ b/src/pages/CloudAgents/agent-chat.css
@@ -3,6 +3,9 @@
 .agent-chat-editor { background: #fffdf9; }
 .agent-chat-workspace-header { background: #fffdf9; border-color: #e9e5de; }
 .agent-chat-workspace-header > button { border-radius: 13px; }
+.agent-chat-workspace-header { flex-wrap: nowrap; min-height: 76px; padding: 12px 24px; }
+.agent-chat-header-avatar { width: 44px; height: 44px; flex-shrink: 0; border: 2px solid #fff; border-radius: 15px; box-shadow: 0 2px 0 #ebe3d6; }
+.agent-chat-header-name { min-width: 0; margin: 0; overflow-wrap: anywhere; color: #303747; font-size: 18px; font-weight: 650; line-height: 1.5; }
 .agent-conversation-workspace { padding: 0; background: #fffdf9; container-type: inline-size; }
 .agent-conversation-sources { display: flex; flex-shrink: 0; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: 8px 16px; padding: 10px 24px; border-bottom: 1px solid #e9e5de; }
 .agent-conversation-source-options { display: flex; gap: 4px; padding: 4px; border: 1px solid #e5e2ee; border-radius: 15px; background: #f2eff7; }
@@ -47,7 +50,8 @@
 .agent-chat-message-content { min-width: 0; flex: 1; }
 .agent-chat-speaker { margin-bottom: 7px; color: #606c7e; font-size: 12px; font-weight: 500; line-height: 1.6; overflow-wrap: anywhere; }
 .agent-chat-styled .agent-chat-message-body { color: #273246; font-size: 15px; line-height: 1.9; overflow-wrap: anywhere; }
-.agent-chat-message[data-role="user"] { align-self: flex-end; width: fit-content; max-width: 85%; padding: 14px 18px; border: 1px solid #e4dbf3; border-radius: 20px 20px 6px 20px; background: #f1ebfb; }
+.agent-chat-message[data-role="user"] { align-self: flex-end; width: fit-content; max-width: 85%; padding: 14px 20px; border: 1px solid #e3d9f0; border-radius: 22px 22px 7px 22px; background: #f0e9f9; box-shadow: 0 2px 0 #e9e1f0; }
+.agent-chat-message[data-role="user"] .agent-chat-message-body p { margin: 0; }
 .agent-chat-message[data-role="user"] .agent-chat-speaker { color: #75628e; }
 .agent-chat-styled .agent-chat-message-body :is(pre, table) { display: block; max-width: 100%; overflow-x: auto; }
 .agent-chat-styled .agent-chat-message-body pre { padding: 14px 16px; border: 1px solid #e4e2dc; border-radius: 13px; background: #f3f2ef; font-size: 13px; line-height: 1.7; overflow-wrap: normal; }
@@ -71,6 +75,44 @@
 .agent-chat-keyboard-hint { color: #747c8a; font-size: 11px; line-height: 1.6; }
 .agent-chat-styled .agent-chat-send, .agent-chat-styled .agent-chat-stop { min-height: 44px; height: auto; flex-shrink: 0; border-radius: 13px; padding: 10px 16px; font-size: 14px; }
 .agent-chat-styled .agent-chat-send { box-shadow: 0 3px 0 #ad3812; }
+.agent-chat-styled .agent-chat-send, .agent-chat-styled .agent-chat-stop { width: 42px; height: 42px; min-height: 42px; padding: 0; border-radius: 14px; }
+.agent-chat-styled .agent-chat-send:disabled { box-shadow: none; }
+.agent-attachment-composer { min-width: 0; }
+.agent-attachment-selected { display: flex; gap: 10px; max-height: 160px; margin: 0 0 12px; padding: 2px 2px 5px; overflow-x: auto; overscroll-behavior: contain; }
+.agent-attachment-card { position: relative; display: flex; flex: 0 0 auto; align-items: center; gap: 10px; width: min(260px, 85%); min-width: 0; padding: 10px 36px 10px 10px; border: 1px solid #e2ddea; border-radius: 15px; background: #f8f5fc; }
+.agent-attachment-icon { display: grid; width: 38px; height: 42px; flex-shrink: 0; place-items: center; border: 1px solid #ddd7e9; border-radius: 10px; background: #fff; color: #846aa4; }
+.agent-attachment-icon svg { width: 20px; height: 20px; }
+.agent-attachment-card[data-kind="image"] { border-color: #dce7dc; background: #f1f7f0; }
+.agent-attachment-card[data-kind="image"] .agent-attachment-icon { border-color: #d8e4d6; color: #63806b; }
+.agent-attachment-card-info { min-width: 0; flex: 1; }
+.agent-attachment-card-info .agent-attachment-name { display: block; }
+.agent-attachment-name { min-width: 0; overflow: hidden; color: #3e4659; font-size: 13px; font-weight: 550; text-overflow: ellipsis; white-space: nowrap; }
+.agent-attachment-size { flex-shrink: 0; color: #677286; font-size: 11px; }
+.agent-attachment-card-info .agent-attachment-size { display: block; margin-top: 3px; }
+.agent-attachment-remove { position: absolute; top: 7px; right: 5px; display: grid; width: 28px; height: 28px; min-height: 28px !important; place-items: center; padding: 0; border: 0; border-radius: 9px; color: #677286; background: transparent; }
+.agent-attachment-remove:hover { background: #e9e1f1; color: #4e405f; }
+.agent-attachment-toolbar { display: flex; flex-wrap: wrap; align-items: center; gap: 7px; margin-top: 8px; }
+.agent-attachment-actions { display: flex; min-width: 0; flex-wrap: wrap; align-items: center; gap: 4px; }
+.agent-attachment-actions > button { min-height: 36px; height: auto; padding: 8px 10px; border-radius: 11px; font-size: 12px; }
+.agent-attachment-toolbar .agent-chat-keyboard-hint { margin-left: auto; }
+.agent-attachment-toolbar > :is(.agent-chat-send, .agent-chat-stop) { margin-left: auto; }
+.agent-attachment-toolbar .agent-chat-keyboard-hint + :is(.agent-chat-send, .agent-chat-stop) { margin-left: 4px; }
+.agent-attachment-error { margin: 10px 0; padding: 10px 12px; border: 1px solid #efdbd1; border-radius: 12px; background: #fff6ed; color: #94522e; font-size: 12px; line-height: 1.7; }
+.agent-attachment-pending { margin-bottom: 12px; padding: 12px; border: 1px solid #dfd8e9; border-radius: 14px; background: #f7f3fc; font-size: 13px; }
+.agent-attachment-library { max-height: min(200px, 25dvh); margin-top: 12px; padding: 12px; overflow-y: auto; overscroll-behavior: contain; border: 1px solid #e3e6dd; border-radius: 14px; background: #f5f7f1; font-size: 13px; }
+.agent-attachment-library :is(button, input, select) { font-size: 12px; }
+.agent-attachment-library button { min-height: 32px; }
+.agent-attachment-library-header, .agent-attachment-library-file { display: flex; align-items: center; gap: 10px; min-height: 38px; }
+.agent-attachment-library-header { justify-content: space-between; color: #5e7162; font-size: 12px; }
+.agent-attachment-library-file > svg, .agent-attachment-library-file > input { flex-shrink: 0; }
+.agent-attachment-library-file > .agent-attachment-name { flex: 1; }
+.agent-attachment-path { min-width: 0; overflow-wrap: anywhere; }
+.agent-attachment-directory { display: flex; min-width: 0; width: 100%; justify-content: flex-start; gap: 8px; }
+.agent-attachment-empty { margin-block: 8px; color: #6c7686; font-size: 12px; }
+.agent-attachment-artifacts { margin-top: 8px; border-top: 1px solid #e1e5dc; padding-top: 8px; }
+.agent-attachment-reading { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; margin-block: 8px; }
+.agent-attachment-reading select { max-width: 100%; min-height: 36px; border: 1px solid #ddd5e8; border-radius: 9px; padding: 5px 8px; background: #fff; }
+.agent-attachment-toolbar + .agent-chat-status, .agent-attachment-composer > .agent-chat-status { margin-top: 8px; }
 .agent-chat-styled :is(button, summary, select) { cursor: pointer; }
 .agent-chat-styled :is(button, textarea, select):focus-visible { outline: 2px solid #9275b4; outline-offset: 3px; }
 .agent-chat-styled :is(button, textarea, select):disabled { cursor: not-allowed; }
@@ -90,9 +132,15 @@
   .agent-chat-styled .agent-chat-message-avatar { width: 30px; height: 30px; border-radius: 10px; }
   .agent-chat-styled .agent-chat-message-body { font-size: 14px; }
   .agent-chat-message[data-role="user"] { max-width: 91%; padding: 12px 14px; }
+  .agent-chat-workspace-header { min-height: 64px; padding: 10px 14px; }
+  .agent-chat-header-name { font-size: 16px; }
+  .agent-chat-header-avatar { width: 38px; height: 38px; border-radius: 13px; }
+  .agent-attachment-actions > button { padding-inline: 9px; }
+  .agent-attachment-card { width: min(230px, 88%); }
   .agent-chat-styled .agent-chat-files, .agent-chat-styled .agent-chat-composer { width: calc(100% - 28px); }
   .agent-chat-styled .agent-chat-composer { margin-bottom: 14px; padding: 12px 13px; border-radius: 20px; }
   .agent-chat-keyboard-hint { display: none; }
+  .agent-attachment-toolbar .agent-chat-keyboard-hint + :is(.agent-chat-send, .agent-chat-stop) { margin-left: auto; }
 }
 @container (max-width: 440px) {
   .agent-conversation-sources { padding-inline: 12px; gap: 8px; }
@@ -119,3 +167,8 @@
 @media (prefers-reduced-motion: reduce) {
   .agent-chat-styled :is(button, textarea, select) { transition: none; }
 }
+
+.agent-chat-reasoning { min-width: 0; margin: 8px 0 14px; color: #667085; font-size: 13px; }
+.agent-chat-reasoning summary { min-height: 36px; width: fit-content; padding: 6px 2px; cursor: pointer; line-height: 24px; }
+.agent-chat-reasoning summary:focus-visible { outline: 2px solid #9275b4; outline-offset: 3px; border-radius: 5px; }
+.agent-chat-reasoning-content { margin-top: 6px; padding-left: 14px; border-left: 2px solid #ddd5e8; white-space: pre-wrap; overflow-wrap: anywhere; line-height: 1.8; }
diff --git a/src/pages/CloudAgents/agent-home.css b/src/pages/CloudAgents/agent-home.css
index d29e0de5..36887d2f 100644
--- a/src/pages/CloudAgents/agent-home.css
+++ b/src/pages/CloudAgents/agent-home.css
@@ -26,29 +26,29 @@
 .agent-home-create svg { width: 19px; height: 19px; }
 .agent-home-back { gap: 6px; margin: -12px 0 16px -12px; color: #606c7e; }
 .agent-home-back svg { width: 17px; height: 17px; }
-.agent-home-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(min(100%, 292px), 1fr)); gap: 20px; }
-.agent-home-card { display: flex; min-width: 0; flex-direction: column; padding: 24px; border: 1px solid #dce5f3; border-radius: 24px; background: #f1f6ff; transition: border-color 160ms ease, box-shadow 160ms ease; }
+.agent-home-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(min(100%, 256px), 256px)); gap: 14px; }
+.agent-home-card { display: flex; min-width: 0; flex-direction: column; padding: 16px; border: 1px solid #dce5f3; border-radius: 18px; background: #f1f6ff; transition: border-color 160ms ease, box-shadow 160ms ease; }
 .agent-home-card[data-tone="1"] { background: #f6f2ff; border-color: #e5dcf5; }
 .agent-home-card[data-tone="2"] { background: #fff5e9; border-color: #f0e2ce; }
 .agent-home-card:hover, .agent-home-card:focus-within { border-color: #bcc9df; box-shadow: 0 4px 16px #2732460a; }
-.agent-home-card-top { display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; margin-bottom: 20px; }
-.agent-home-avatar { width: 72px; height: 72px; flex-shrink: 0; overflow: hidden; border: 3px solid #fff; border-radius: 22px; background: #fff6de; box-shadow: 0 2px 5px #27324608; }
+.agent-home-card-top { display: flex; align-items: flex-start; justify-content: space-between; gap: 8px; margin-bottom: 10px; }
+.agent-home-avatar { width: 48px; height: 48px; flex-shrink: 0; overflow: hidden; border: 2px solid #fff; border-radius: 16px; background: #fff6de; box-shadow: 0 2px 5px #27324608; }
 .agent-home-avatar img { width: 100%; height: 100%; object-fit: cover; }
 .agent-home-avatar .agent-home-builtin-avatar { image-rendering: pixelated; }
-.agent-home-status { display: inline-flex; align-items: center; gap: 6px; margin-top: 4px; padding: 5px 10px; border-radius: 20px; font-size: 12px; font-weight: 500; line-height: 1.5; color: #765229; background: #fff9eb; white-space: nowrap; }
+.agent-home-status { display: inline-flex; align-items: center; gap: 6px; margin-top: 4px; padding: 4px 8px; border-radius: 20px; font-size: 12px; font-weight: 500; line-height: 1.5; color: #765229; background: #fff9eb; white-space: nowrap; }
 .agent-home-status::before { width: 6px; height: 6px; flex-shrink: 0; border-radius: 50%; background: #af7c36; content: ''; }
 .agent-home-card[data-state="ready"] .agent-home-status { color: #38684d; background: #e3f4e9; }
 .agent-home-card[data-state="ready"] .agent-home-status::before { background: #498264; }
 .agent-home-card[data-state="inactive"] .agent-home-status { color: #606c7e; background: #e9edf2; }
 .agent-home-card[data-state="inactive"] .agent-home-status::before { background: #778294; }
-.agent-home-card h2 { overflow: hidden; font-size: 21px; font-weight: 650; line-height: 1.5; text-overflow: ellipsis; white-space: nowrap; }
-.agent-home-purpose { display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 3; min-height: 78px; overflow: hidden; margin-top: 8px; font-size: 15px; line-height: 26px; color: #606c7e; white-space: pre-wrap; overflow-wrap: anywhere; }
-.agent-home-card-actions { display: flex; flex-wrap: wrap; align-items: center; gap: 6px; margin-top: auto; padding-top: 20px; }
-.agent-home-card-primary { gap: 7px; border-radius: 12px; font-size: 14px; }
+.agent-home-card h2 { overflow: hidden; font-size: 18px; font-weight: 650; line-height: 1.5; text-overflow: ellipsis; white-space: nowrap; }
+.agent-home-purpose { display: -webkit-box; -webkit-box-orient: vertical; -webkit-line-clamp: 2; min-height: 42px; overflow: hidden; margin-top: 6px; font-size: 14px; line-height: 21px; color: #606c7e; white-space: pre-wrap; overflow-wrap: anywhere; }
+.agent-home-card-actions { display: flex; flex-wrap: wrap; align-items: center; gap: 4px; margin-top: auto; padding-top: 10px; }
+.agent-home-card .agent-home-card-primary { gap: 6px; padding-inline: 10px; border-radius: 12px; font-size: 14px; }
 .agent-home-card-primary svg { width: 17px; height: 17px; }
 .agent-home-card-primary.border { border-color: #c6ccda; background: #ffffffb3; color: #35435b; }
-.agent-home-adjust { padding-inline: 9px; border-radius: 12px; color: #546176; }
-.agent-home-delete { gap: 5px; margin-left: auto; padding-inline: 8px; border-radius: 12px; color: #836b73; }
+.agent-home-card .agent-home-adjust { padding-inline: 8px; border-radius: 12px; color: #546176; }
+.agent-home-card .agent-home-delete { gap: 5px; margin-left: auto; padding-inline: 6px; border-radius: 12px; color: #836b73; }
 .agent-home-delete svg { width: 16px; height: 16px; }
 .agent-home-delete:hover { color: #ac3d49; background: #fce9e9; }
 .agent-home-delete-dialog { border-radius: 24px; }
@@ -72,11 +72,13 @@
   .agent-home-greeting h1 { font-size: 26px; }
   .agent-home-greeting-doodle { display: none; }
   .agent-home-header-actions { flex-wrap: wrap; }
-  .agent-home-card { padding: 22px; }
   .agent-home-empty { min-height: 360px; padding-inline: 20px; }
   .agent-home-empty h2 { font-size: 22px; }
   .agent-home-error { align-items: flex-start; flex-wrap: wrap; }
 }
+@media (max-width: 560px) {
+  .agent-home-grid { grid-template-columns: minmax(0, 1fr); }
+}
 @media (prefers-reduced-motion: reduce) {
   .agent-home-card { transition: none; }
   .agent-home-greeting-doodle { animation: none; }
diff --git a/src/pages/CloudAgents/cloud-chat-stream.ts b/src/pages/CloudAgents/cloud-chat-stream.ts
new file mode 100644
index 00000000..79b6f79d
--- /dev/null
+++ b/src/pages/CloudAgents/cloud-chat-stream.ts
@@ -0,0 +1,58 @@
+export interface CloudChatStream {
+  runId: string;
+  threadId: string;
+  requestId?: string;
+  cursor: string;
+  content: string;
+  reasoning: string;
+  messageId: string;
+  reasoningMessageId: string;
+  ended: boolean;
+  toolName: string;
+}
+
+const object = (value: unknown): Record<string, unknown> => value && typeof value === 'object' && !Array.isArray(value)
+  ? value as Record<string, unknown> : {};
+const validCursor = (value: string) => /^\d+-\d+$/.test(value);
+function newerCursor(next: string, previous: string) {
+  const [nextTime, nextIndex] = next.split('-').map(BigInt);
+  const [previousTime, previousIndex] = previous.split('-').map(BigInt);
+  return nextTime > previousTime || nextTime === previousTime && nextIndex > previousIndex;
+}
+
+/** Project only the subscribed Run's main-thread messages; Redis IDs survive reconnects. */
+export function consumeCloudChatEvent(previous: CloudChatStream | null, value: unknown, type: string, eventId: string,
+  runId: string, threadId: string, requestId?: string): CloudChatStream | null {
+  const envelope = object(value);
+  if (envelope.run_id !== runId || requestId && envelope.request_id && envelope.request_id !== requestId) return previous;
+  const continuation = previous?.threadId === threadId && requestId && previous.requestId === requestId;
+  const current: CloudChatStream = previous?.runId === runId && previous.threadId === threadId ? previous : {
+    runId, threadId, requestId, cursor: '0-0', content: '', reasoning: continuation ? previous.reasoning : '',
+    messageId: '', reasoningMessageId: continuation ? previous.reasoningMessageId : '', ended: false, toolName: '',
+  };
+  const fresh = validCursor(eventId) && newerCursor(eventId, current.cursor);
+  // A synthesized terminal event can reuse the last message's Redis ID.
+  if (type === 'end' && envelope.thread_id === threadId) return { ...current, ended: true, cursor: fresh ? eventId : current.cursor };
+  if (validCursor(eventId) && !fresh) return previous;
+  const next = { ...current, cursor: fresh ? eventId : current.cursor };
+  // Child events still advance the replay cursor, but never become visible text.
+  if (envelope.thread_id !== threadId) return next;
+  const payload = object(envelope.payload);
+  for (const item of Array.isArray(payload.items) ? payload.items : payload.chunk ? [payload.chunk] : []) {
+    const event = object(object(item).stream_event);
+    if (event.type === 'tool_call' && typeof event.name === 'string') next.toolName = event.name;
+    if (event.type !== 'message_delta') continue;
+    const id = typeof event.message_id === 'string' ? event.message_id : next.messageId;
+    const reasoning = typeof event.reasoning_content === 'string' ? event.reasoning_content
+      : typeof event.additional_reasoning_content === 'string' ? event.additional_reasoning_content : '';
+    if (reasoning) {
+      next.reasoning += (next.reasoning && next.reasoningMessageId && id !== next.reasoningMessageId ? '\n\n' : '') + reasoning;
+      next.reasoningMessageId = id;
+    }
+    if (typeof event.content === 'string' && event.content) {
+      next.content += (next.content && next.messageId && id !== next.messageId ? '\n\n' : '') + event.content;
+      next.messageId = id;
+    }
+  }
+  return next;
+}
diff --git a/tests/e2e/cloud-agent-channels.spec.ts b/tests/e2e/cloud-agent-channels.spec.ts
index c9ec06ae..8b0190e4 100644
--- a/tests/e2e/cloud-agent-channels.spec.ts
+++ b/tests/e2e/cloud-agent-channels.spec.ts
@@ -1,6 +1,6 @@
 import { closeElectronApp, expect, getStableWindow, test } from './fixtures/electron';
 
-test('own WeChat conversation approval and generated PPT delivery in the desktop workspace', async ({ launchElectronApp }, testInfo) => {
+test('WeChat binding cards connect an account and switch its Agent through the channel workspace', async ({ launchElectronApp }, testInfo) => {
   const app = await launchElectronApp({ skipSetup: true });
   const agentSlug = 'ml-' + 'a'.repeat(32);
   const secondAgentSlug = 'ml-' + 'b'.repeat(32);
@@ -13,14 +13,12 @@ test('own WeChat conversation approval and generated PPT delivery in the desktop
       BrowserWindow.getAllWindows()[0].setSize(1366, 900);
       const calls: { operation: string; input: unknown }[] = [];
       Object.assign(globalThis, { cloudChannelFixtureCalls: calls });
-      let approved = false;
       let verified = false;
       const slug = 'ml-' + 'a'.repeat(32);
       const configuration = { model: 'test-model', tools: [], knowledges: [], mcps: [], skills: [], preload_skills: [], subagents: [], tool_approval_mode: 'default', max_execution_steps: 40, max_output_tokens: 4096, max_run_seconds: 600 };
       const draft = { slug, name: '我的创作助手', purpose: '整理选题与制作演示文稿', system_prompt: '使用简洁自然的中文', draft_revision: 2, updated_at: '2026-09-13T00:00:00Z', configuration, published_version: 1, enabled: true, archived: false };
       const secondSlug = 'ml-' + 'b'.repeat(32);
       const secondDraft = { ...draft, slug: secondSlug, name: '资料整理助手', draft_revision: 1, published_version: 1 };
-      const session = { session_id: 'self-session', caller_id: 'self-caller', agent_slug: slug, agent_name: draft.name, binding_id: 'binding-a', provider_generation: 'generation-a', channel_account_id: 'wechat-a', access_mode: 'self_only', grant_state: 'authorized', session_state: 'active', sequence: 1, thread_id: 'channel-thread', created_at: '2026-09-13T01:00:00Z' };
       const channel = { id: 'wechat-a', address: 'wechat:personal', display_name: '创作微信', target_agent_address: 'yuxi:makelore:' + slug, route_revision: 3, provider_generation: 'generation-a', binding_id: 'binding-a', enabled: true, status: 'active', worker_online: true, agent_slug: slug, published_version: 1, desired_state: 'enabled', sync_state: 'ready', health: 'connected', last_confirmed_at: '2026-09-13T01:00:00Z', revision: 3, blockers: [], access_mode: 'self_only', policy_revision: 0, target_agent_slug: slug, target_agent_name: draft.name, target_agent_published_version: 1 };
       const spare = { id: 'wechat-b', address: 'wechat:spare', display_name: '备用微信', target_agent_address: null, route_revision: 1, provider_generation: 'generation-b', binding_id: 'binding-b', enabled: false, status: 'paused', worker_online: true, agent_slug: null, published_version: null, desired_state: 'disabled', sync_state: 'ready', health: 'login_required', last_confirmed_at: null, revision: 1, blockers: ['target_required'], access_mode: 'self_only', policy_revision: 0, target_agent_slug: null, target_agent_name: null, target_agent_published_version: null };
       let channelAccounts = [channel, spare];
@@ -35,7 +33,6 @@ test('own WeChat conversation approval and generated PPT delivery in the desktop
         const body = typeof request.body === 'string' ? JSON.parse(request.body) : request.body ?? {};
         if (path.endsWith('/recovery')) return result({ recent: null, pending: [] });
         if (path.endsWith('/recovery/recent')) return result({ saved: true });
-        if (path.endsWith('/files/save-channel')) { calls.push({ operation: 'downloadChannelArtifact', input: body }); return result({ saved: true }); }
         if (!path.endsWith('/actions')) return result(path.endsWith('/agents') || path.endsWith('/bootstrap') ? { agents: [draft, secondDraft], next_cursor: null } : path.endsWith(secondSlug) ? secondDraft : draft);
         const { operation, input = {} } = body;
         calls.push({ operation, input });
@@ -70,18 +67,8 @@ test('own WeChat conversation approval and generated PPT delivery in the desktop
           return result({ channel: channelAccounts.find(item => item.id === input.channel_account_id), disconnected: true });
         }
         if (operation === 'channelBindings') return result({ items: channelAccounts.filter(item => item.target_agent_slug === input.slug), available_accounts: [] });
-        if (operation === 'channelConversations') return result({ items: [session], next_offset: null });
-        if (operation === 'channelSelfCallers') return result({ items: [{ ...session, paired_ws_account_id: 'creator', revoked_at: null }] });
-        if (operation === 'channelActivity') return result({ items: [], next_offset: null });
-        if (operation === 'wechatBindStart' || operation === 'wechatBindStatus' || operation === 'channelAccountWechatBindStart' || operation === 'channelAccountWechatBindStatus') return result({ session_key: 'qr-session', status: verified ? 'confirmed' : 'verification_required', qrcode_url: 'https://login.example.test/confirm?token=fixture', message: '请确认微信验证码' });
-        if (operation === 'wechatBindVerification' || operation === 'channelAccountWechatBindVerification') { verified = true; channelAccounts = channelAccounts.map(item => item.id === input.channel_account_id ? { ...item, health: 'connected' } : item); return result({ session_key: 'qr-session', status: 'confirmed', message: '连接已确认' }); }
-        if (operation === 'channelConversation') return result({ ...session, messages: [{ id: 1, role: 'user', content: '把今天的创作建议整理成演示文稿。' }, ...(approved ? [{ id: 2, role: 'assistant', content: '## 演示文稿已完成\n共 7 页，文件已保存在本次会话中。' }] : [])], queued_requests: [], next_offset: null,
-          run: { agent_run_id: 'channel-run', request_id: 'channel-request', thread_id: 'channel-thread', agent_slug: slug, status: approved ? 'completed' : 'interrupted', output: '', version: '1',
-            ...(approved ? {} : { interrupt: { approval: { action_requests: [{ name: 'execute', args: { command: 'python create_presentation.py' } }] } } }) } });
-        if (operation === 'channelConversationControl') { approved = true; return result({ session_id: session.session_id, operation_id: input.operation_id, action: input.action, status: 'accepted', run_id: 'channel-run' }); }
-        if (operation === 'channelFiles') return result({ session_id: session.session_id, thread_id: session.thread_id, files: !approved ? [] : input.path === '/'
-          ? [{ name: 'outputs', path: '/outputs', directory_path: '/outputs', is_dir: true, size: 0 }]
-          : [{ name: '创作建议.pptx', path: '/outputs/创作建议.pptx', directory_path: '/outputs', is_dir: false, size: 40960 }] });
+        if (operation === 'channelAccountWechatBindStart' || operation === 'channelAccountWechatBindStatus') return result({ session_key: 'qr-session', status: verified ? 'confirmed' : 'verification_required', qrcode_url: 'https://login.example.test/confirm?token=fixture', message: '请确认微信验证码' });
+        if (operation === 'channelAccountWechatBindVerification') { verified = true; channelAccounts = channelAccounts.map(item => item.id === input.channel_account_id ? { ...item, health: 'connected' } : item); return result({ session_key: 'qr-session', status: 'confirmed', message: '连接已确认' }); }
         if (operation === 'schedules') return result({ jobs: [] });
         if (operation === 'scheduleContext') return result({ version: 1, enabled: true, configuration, result_destination: '任务历史', payer: 'creator' });
         throw new Error('Unexpected channel UI fixture operation ' + operation);
@@ -90,20 +77,12 @@ test('own WeChat conversation approval and generated PPT delivery in the desktop
     await page.goto(applicationUrl);
     await page.getByTestId('ai-module-option-cloud_agents').click();
     await page.getByRole('article', { name: '我的创作助手', exact: true }).getByRole('button', { name: '和它聊聊', exact: true }).click();
-    await page.getByRole('button', { name: '微信对话', exact: true }).click();
-    const own = page.getByRole('region', { name: '微信会话', exact: true });
-    await expect(own.getByTestId('wechat-run-status')).toContainText('任务状态：等待你的确认');
-    await own.getByRole('button', { name: '允许执行', exact: true }).click();
-    await expect(own.getByRole('heading', { name: '演示文稿已完成' })).toBeVisible();
-    await expect(own.getByTestId('wechat-run-status')).toContainText('任务状态：已完成');
-    await own.getByRole('button', { name: '保存 创作建议.pptx', exact: true }).click();
-    await expect(own.getByText('已保存 创作建议.pptx', { exact: true })).toBeVisible();
-    await page.screenshot({ path: testInfo.outputPath('wechat-own-deliverables.png') });
-    const calls = await app.evaluate(() => (globalThis as typeof globalThis & { cloudChannelFixtureCalls: { operation: string; input: Record<string, unknown> }[] }).cloudChannelFixtureCalls);
-    expect(calls.find(call => call.operation === 'channelConversationControl')?.input).toMatchObject({ session_id: 'self-session', run_id: 'channel-run', action: 'resume', decision: { decisions: [{ type: 'approve' }] } });
-    expect(calls.find(call => call.operation === 'downloadChannelArtifact')?.input).toEqual({ session_id: 'self-session', path: '/outputs/创作建议.pptx' });
-    expect(calls.some(call => call.operation === 'resume' || call.operation === 'submit')).toBe(false);
-    await page.getByTestId('cloud-agent-editor').getByRole('button', { name: '我的智能体', exact: true }).click();
+    await expect(page.getByRole('region', { name: '智能体对话', exact: true })).toBeVisible();
+    await expect(page.getByRole('heading', { name: '我的创作助手', exact: true })).toBeVisible();
+    await expect(page.getByRole('button', { name: '微信对话', exact: true })).toHaveCount(0);
+    await expect(page.getByRole('navigation', { name: '对话来源', exact: true })).toHaveCount(0);
+    await expect(page.getByRole('region', { name: '微信会话', exact: true })).toHaveCount(0);
+    await page.getByRole('button', { name: '返回智能体列表', exact: true }).click();
     await page.getByRole('button', { name: '渠道', exact: true }).click();
     await expect(page.getByRole('heading', { name: '连接到微信', exact: true })).toBeVisible();
     const legacyCard = page.getByRole('article', { name: '创作微信微信', exact: true });
@@ -113,7 +92,6 @@ test('own WeChat conversation approval and generated PPT delivery in the desktop
     await expect(page.getByRole('dialog')).toHaveCount(0);
     await expect(page.getByText('活动记录', { exact: true })).toHaveCount(0);
     await expect(page.getByRole('button', { name: '微信对话', exact: true })).toHaveCount(0);
-    const callsBeforeConfig = await app.evaluate(() => (globalThis as typeof globalThis & { cloudChannelFixtureCalls: { operation: string }[] }).cloudChannelFixtureCalls.length);
     await page.screenshot({ path: testInfo.outputPath('wechat-binding-cards.png'), fullPage: true });
 
     await page.getByRole('button', { name: '添加微信', exact: true }).click();
@@ -146,6 +124,8 @@ test('own WeChat conversation approval and generated PPT delivery in the desktop
     await switching.getByRole('button', { name: /确认更换/ }).click();
     await expect.poll(async () => app.evaluate(() => (globalThis as typeof globalThis & { cloudChannelFixtureCalls: { operation: string; input: Record<string, unknown> }[] }).cloudChannelFixtureCalls
       .filter(call => call.operation === 'routeChannelAccount').some(call => call.input.channel_account_id === 'wechat-a' && call.input.target_agent_slug === 'ml-' + 'b'.repeat(32) && call.input.enabled === true))).toBe(true);
+    await expect(managing.getByText('已更换绑定的智能体，微信连接保留。', { exact: true })).toBeVisible();
+    await expect(managing.getByLabel('绑定的智能体', { exact: true })).toHaveValue(secondAgentSlug);
     expect(await app.evaluate(() => (globalThis as typeof globalThis & { cloudChannelFixtureCalls: { operation: string }[] }).cloudChannelFixtureCalls.filter(call => call.operation === 'channelAccountWechatBindStart').length)).toBe(qrStartsBeforeSwitch);
     await expect(page.getByText('活动记录', { exact: true })).toHaveCount(0);
     await expect(page.getByRole('button', { name: '微信对话', exact: true })).toHaveCount(0);
@@ -153,9 +133,19 @@ test('own WeChat conversation approval and generated PPT delivery in the desktop
     await app.evaluate(({ BrowserWindow }) => { const win = BrowserWindow.getAllWindows()[0]; win.setMinimumSize(800, 600); win.setSize(980, 680); });
     await expect.poll(() => page.getByTestId('main-content').evaluate(element => element.scrollWidth - element.clientWidth)).toBeLessThanOrEqual(1);
     await page.screenshot({ path: testInfo.outputPath('wechat-manage-binding-compact.png'), fullPage: true });
-    const finalCalls = await app.evaluate(() => (globalThis as typeof globalThis & { cloudChannelFixtureCalls: { operation: string }[] }).cloudChannelFixtureCalls);
-    expect(finalCalls.slice(callsBeforeConfig).some(call => ['channelActivity', 'channelConversations', 'channelConversation', 'channelPolicy', 'createChannelPairing', 'channelCallers', 'revokeChannelCaller'].includes(call.operation))).toBe(false);
+    await managing.getByRole('button', { name: '关闭', exact: true }).click();
+    await expect(managing).toHaveCount(0);
+    await expect(legacyCard.getByText('资料整理助手', { exact: true })).toBeVisible();
+    const finalCalls = await app.evaluate(() => (globalThis as typeof globalThis & { cloudChannelFixtureCalls: { operation: string; input: Record<string, unknown> }[] }).cloudChannelFixtureCalls);
+    expect(finalCalls.some(call => ['channelActivity', 'channelConversations', 'channelConversation', 'channelConversationControl', 'channelFiles', 'downloadChannelArtifact', 'channelPolicy', 'createChannelPairing', 'channelCallers', 'channelSelfCallers', 'revokeChannelCaller', 'submit', 'preview', 'resume'].includes(call.operation))).toBe(false);
     expect(finalCalls.filter(call => call.operation === 'createChannelAccount')).toHaveLength(1);
+    expect(finalCalls.find(call => call.operation === 'createChannelAccount')?.input).toEqual({ display_name: '新创作微信', operation_id: expect.any(String) });
+    expect(finalCalls.find(call => call.operation === 'channelAccountWechatBindVerification')?.input).toEqual({ channel_account_id: 'wechat-created', session_key: 'qr-session', verify_code: '123456', operation_id: expect.any(String) });
+    expect(finalCalls.find(call => call.operation === 'enableChannelAccount')?.input).toEqual({ channel_account_id: 'wechat-created', expected_revision: 2, operation_id: expect.any(String) });
+    expect(finalCalls.filter(call => call.operation === 'routeChannelAccount').map(call => call.input)).toEqual([
+      { channel_account_id: 'wechat-created', target_agent_slug: agentSlug, expected_revision: 1, enabled: false, operation_id: expect.any(String) },
+      { channel_account_id: 'wechat-a', target_agent_slug: secondAgentSlug, expected_revision: 3, enabled: true, operation_id: expect.any(String) },
+    ]);
 
   } finally {
     await app.evaluate(({ BrowserWindow }) => { for (const window of BrowserWindow.getAllWindows()) window.destroy(); }).catch(() => undefined);
diff --git a/tests/e2e/cloud-agent-chat-layout.spec.ts b/tests/e2e/cloud-agent-chat-layout.spec.ts
index 8fd4cdeb..a7e640d4 100644
--- a/tests/e2e/cloud-agent-chat-layout.spec.ts
+++ b/tests/e2e/cloud-agent-chat-layout.spec.ts
@@ -1,13 +1,13 @@
 import { test, expect, type Page } from '@playwright/test';
 import { createServer, type ViteDevServer } from 'vite';
 import { resolve } from 'node:path';
-import type { CloudHistory, CloudInterrupt, CloudRun, CloudThread } from '../../shared/cloud-agents';
+import type { CloudAttachment, CloudHistory, CloudInterrupt, CloudRun, CloudThread } from '../../shared/cloud-agents';
 
 let server: ViteDevServer;
 let baseUrl: string;
 test.use({ headless: true, channel: process.env.MAKELORE_LAYOUT_BROWSER_CHANNEL, video: 'off' });
 
-// The real CloudChat, Markdown renderer and CloudFiles are used. Main IPC and
+// The real CloudChat, Markdown renderer and attachment composer are used. Main IPC and
 // the event stream are isolated fixtures; this suite never starts a native app
 // or contacts an account, cloud service or model.
 test.beforeAll(async () => {
@@ -25,15 +25,13 @@ test.beforeAll(async () => {
         if (id === entry) return `
           import { createRoot } from 'react-dom/client';
           import { CloudChat } from '/src/pages/CloudAgents/CloudChat.tsx';
-          import { Button } from '/src/components/ui/button.tsx';
           import avatar from '/src/assets/agent-avatars/avatar-05.png';
           import '/src/styles/globals.css';
           const examples = ['我想一起想一个有趣的故事。', '请帮我把今天的新发现整理一下。'];
           createRoot(document.getElementById('root')).render(
             <main className="flex h-screen min-h-0 min-w-0 flex-col">
               <CloudChat slug="ml-chat-layout-fixture" assistantName="我的故事搭档" assistantAvatarUrl={avatar}
-                examples={examples} headerAction={<Button variant="outline" data-testid="fixture-adjust"
-                  onClick={() => window.__cloudChatFixture.adjustments++}>调整智能体</Button>} />
+                examples={examples} />
             </main>
           );
         `;
@@ -91,31 +89,42 @@ function makeHistory(thread: CloudThread, dense = false, run: CloudRun | null =
 
 type FixtureCall = { path: string; method: string; input: Record<string, unknown> | null };
 type FixtureSeed = { threads: CloudThread[]; histories: Record<string, CloudHistory> };
-type FixtureState = FixtureSeed & { calls: FixtureCall[]; adjustments: number };
+type FixtureStream = EventTarget & { readyState: number; url: string };
+type FixtureState = FixtureSeed & { calls: FixtureCall[]; attachments: CloudAttachment[]; streams: FixtureStream[] };
 type FixtureWindow = Window & { __cloudChatFixture: FixtureState };
+type FixtureKind = 'empty' | 'history' | 'running' | 'approval' | 'thinking';
 
-async function installFixture(page: Page, kind: 'empty' | 'history' | 'running' | 'approval') {
-  const first = makeThread('story-first', '小狐狸的故事', kind === 'running' ? 'running' : kind === 'approval' ? 'interrupted' : 'completed');
+async function installFixture(page: Page, kind: FixtureKind) {
+  const isRunning = kind === 'running' || kind === 'thinking';
+  const first = makeThread('story-first', '小狐狸的故事', isRunning ? 'running' : kind === 'approval' ? 'interrupted' : 'completed');
   const second = makeThread('story-second', '另一段故事');
   const interrupt: CloudInterrupt = { approval: { action_requests: [{ name: 'execute',
     description: '把刚才确认的故事保存到我的故事笔记', args: { path: '/stories/' + longWord, content: '保留我们的故事想法。' } }] } };
-  const run = kind === 'running' ? makeRun(first, 'running') : kind === 'approval' ? makeRun(first, 'interrupted', interrupt) : null;
+  const run = isRunning ? makeRun(first, 'running') : kind === 'approval' ? makeRun(first, 'interrupted', interrupt) : null;
   const seed: FixtureSeed = kind === 'empty' ? { threads: [], histories: {} } : {
     threads: [first, second], histories: {
-      [first.thread_id]: makeHistory(first, kind !== 'approval', run),
+      [first.thread_id]: kind === 'thinking' ? { ...makeHistory(first, false, run), messages: [] } : makeHistory(first, kind !== 'approval', run),
       [second.thread_id]: makeHistory(second),
     },
   };
   await page.addInitScript(({ seed }) => {
     const scope = window as unknown as FixtureWindow;
-    scope.__cloudChatFixture = { ...seed, calls: [], adjustments: 0 };
+    scope.__cloudChatFixture = { ...seed, calls: [], attachments: [{ file_id: 'attachment-story', file_name: '我的故事笔记与新发现.txt', file_size: 4096 }], streams: [] };
     const state = scope.__cloudChatFixture;
+    const persisted = sessionStorage.getItem('cloud-chat-fixture-durable');
+    if (persisted) {
+      const { history, thread } = JSON.parse(persisted) as { history: CloudHistory; thread: CloudThread };
+      state.histories[thread.thread_id] = history;
+      state.threads[0] = thread;
+    }
     const result = (json: unknown) => ({ ok: true, data: { status: 200, ok: true, json: structuredClone(json) } });
     // Keep durable run polling real, but prevent EventSource from reaching a network.
     class FixtureEventSource extends EventTarget {
       readyState = 1;
+      url: string;
       onopen: ((event: Event) => void) | null = null;
       onerror: ((event: Event) => void) | null = null;
+      constructor(url: string) { super(); this.url = url; state.streams.push(this); }
       close() { this.readyState = 2; }
     }
     Object.defineProperty(window, 'EventSource', { value: FixtureEventSource });
@@ -130,6 +139,7 @@ async function installFixture(page: Page, kind: 'empty' | 'history' | 'running'
         state.calls.push({ path, method, input });
         if (path === '/api/cloud-agents/recovery') return result({ recent: null, pending: [] });
         if (path === '/api/cloud-agents/recovery/recent') return result({ saved: true });
+        if (path === '/api/cloud-agents/attachments/pick') return result({ object_name: 'temporary/狐狸照片.png', file_name: '狐狸照片.png', file_type: 'png', parse_supported: true, parse_methods: ['disable', 'rapid_ocr'] });
         if (path !== '/api/cloud-agents/actions') throw new Error('Unexpected fixture path: ' + path);
         const operation = String(input?.operation);
         const args = input?.input as Record<string, unknown> | undefined;
@@ -139,8 +149,13 @@ async function installFixture(page: Page, kind: 'empty' | 'history' | 'running'
           case 'threads': return result({ threads: state.threads, next_offset: null });
           case 'history': return result(history);
           case 'viewed': return result({ viewed: true });
-          case 'attachments': return result({ attachments: [{ file_id: 'attachment-story', file_name: '我的故事笔记与新发现.txt', file_size: 4096 }] });
-          case 'files': return result({ files: [{ name: '故事笔记.md', is_dir: false, path: '/故事笔记.md' }] });
+          case 'attachments': return result({ attachments: state.attachments });
+          case 'confirmAttachment': {
+            const attachment = { file_id: 'attachment-photo', file_name: '狐狸照片.png', file_size: 8192 };
+            if (!state.attachments.some(item => item.file_id === attachment.file_id)) state.attachments.push(attachment);
+            return result({ attachments: [attachment] });
+          }
+          case 'files': return result({ files: [{ name: '故事笔记.md', is_dir: false, path: '/故事笔记.md', size: 1024 }] });
           case 'run': return result(Object.values(state.histories).find(item => item.run?.agent_run_id === args?.run_id)?.run);
           case 'cancelRun': return result({ status: 'cancel_requested' });
           case 'resume': {
@@ -160,7 +175,7 @@ async function installFixture(page: Page, kind: 'empty' | 'history' | 'running'
   });
 }
 
-async function openChat(page: Page, kind: 'empty' | 'history' | 'running' | 'approval', width: number, height: number) {
+async function openChat(page: Page, kind: FixtureKind, width: number, height: number) {
   const errors: string[] = [];
   page.on('pageerror', error => errors.push(error.message));
   await page.setViewportSize({ width, height });
@@ -169,6 +184,10 @@ async function openChat(page: Page, kind: 'empty' | 'history' | 'running' | 'app
   await expect(page.getByRole('region', { name: '智能体对话', exact: true })).toBeVisible();
   await expect(page.getByLabel('消息', { exact: true })).toBeEnabled();
   await expect(page.getByText('正在读取对话…', { exact: true })).toHaveCount(0);
+  await expect(page.locator('.agent-chat-toolbar')).toHaveCount(0);
+  await expect(page.getByRole('button', { name: /^(已保存|已应用|调整智能体|查看历史对话|新对话|客户端对话|微信对话)$/ })).toHaveCount(0);
+  await expect(page.getByRole('navigation', { name: '对话来源', exact: true })).toHaveCount(0);
+  await expect(page.getByText(/由创建者支付词元点数|和助手聊一聊/)).toHaveCount(0);
   return errors;
 }
 
@@ -202,6 +221,14 @@ async function screenshot(page: Page, name: string) {
   await test.info().attach(name, { path, contentType: 'image/png' });
 }
 
+async function emitRunEvent(page: Page, type: 'messages' | 'end', id: string, envelope: Record<string, unknown>) {
+  await page.evaluate(({ type, id, envelope }) => {
+    const stream = (window as unknown as FixtureWindow).__cloudChatFixture.streams.filter(item => item.readyState === 1).at(-1);
+    if (!stream) throw new Error('Missing active fixture stream');
+    stream.dispatchEvent(new MessageEvent(type, { lastEventId: id, data: JSON.stringify(envelope) }));
+  }, { type, id, envelope });
+}
+
 for (const width of [375, 768, 1024, 1440]) {
   test(`friendly empty conversation keeps the composer reachable at ${width}px`, async ({ page }) => {
     const errors = await openChat(page, 'empty', width, width === 375 ? 640 : 760);
@@ -228,6 +255,13 @@ for (const viewport of [{ width: 375, height: 540 }, { width: 1440, height: 900
     const transcript = page.getByTestId('cloud-chat-messages');
     const composer = page.getByTestId('cloud-chat-composer');
     await expect(transcript.getByRole('article')).toHaveCount(16);
+    const userBubble = transcript.locator('.agent-chat-message[data-role="user"]').first();
+    const bubbleStyle = await userBubble.evaluate(element => {
+      const style = getComputedStyle(element);
+      return { background: style.backgroundColor, radius: Number.parseFloat(style.borderTopLeftRadius) };
+    });
+    expect(bubbleStyle.background).not.toBe('rgba(0, 0, 0, 0)');
+    expect(bubbleStyle.radius).toBeGreaterThan(0);
     await expect(transcript.locator('pre')).toHaveCount(1);
     await expect(transcript.locator('table')).toHaveCount(1);
     await expectComposerBounds(page);
@@ -244,26 +278,58 @@ for (const viewport of [{ width: 375, height: 540 }, { width: 1440, height: 900
     const input = page.getByLabel('消息', { exact: true });
     await input.fill(Array.from({ length: 6 }, (_, index) => `第 ${index + 1} 行未发送的故事想法`).join('\n'));
     await expectComposerBounds(page);
-    await page.getByRole('button', { name: '查看历史对话', exact: true }).click();
-    const history = page.getByLabel('历史对话', { exact: true });
-    await expect(history).toBeDisabled();
+    await expect(page.getByRole('button', { name: '查看历史对话', exact: true })).toHaveCount(0);
+    await expect(page.getByLabel('历史对话', { exact: true })).toHaveCount(0);
+    await expect(transcript.getByRole('article')).toHaveCount(16);
     await input.fill('');
-    await expect(history).toBeEnabled();
-    await history.selectOption('story-second');
-    await expect(transcript.getByText('这是另一段保留下来的故事对话。', { exact: true })).toBeVisible();
-    await expect(transcript.getByRole('article')).toHaveCount(1);
-    await page.locator('.agent-chat-files summary').click();
-    await expect(page.getByRole('button', { name: '添加附件', exact: true })).toBeVisible();
+    await page.getByRole('button', { name: '对话文件', exact: true }).click();
+    await expect(page.getByRole('button', { name: '添加文件或图片', exact: true })).toBeVisible();
     await expect(page.getByRole('button', { name: '保存 故事笔记.md', exact: true })).toBeVisible();
+    const chosen = page.getByRole('checkbox', { name: '选择附件 我的故事笔记与新发现.txt', exact: true });
+    await chosen.check();
+    await expect(composer.getByRole('button', { name: '移除附件 我的故事笔记与新发现.txt', exact: true })).toBeVisible();
+    await composer.getByRole('button', { name: '移除附件 我的故事笔记与新发现.txt', exact: true }).click();
+    await expect(chosen).not.toBeChecked();
+    await expect(composer.locator('.agent-attachment-selected')).toHaveCount(0);
+    expect((await operations(page)).some(item => item?.operation === 'deleteAttachment')).toBe(false);
+    await page.getByRole('button', { name: '对话文件', exact: true }).click();
     await expectComposerBounds(page);
     expect((await operations(page)).some(item => ['submit', 'preview', 'resume'].includes(String(item?.operation)))).toBe(false);
     expect(errors).toEqual([]);
   });
 }
 
+for (const width of [375, 1440]) {
+  test(`a picked image is added inline and can be deselected without deleting it at ${width}px`, async ({ page }) => {
+    const errors = await openChat(page, 'history', width, width === 375 ? 640 : 900);
+    const composer = page.getByTestId('cloud-chat-composer');
+    const send = composer.getByRole('button', { name: '发送', exact: true });
+    await expect(send).toBeDisabled();
+    await composer.getByRole('button', { name: '添加文件或图片', exact: true }).click();
+    const remove = composer.getByRole('button', { name: '移除附件 狐狸照片.png', exact: true });
+    await expect(remove).toBeVisible();
+    await expect(composer.locator('.agent-attachment-card[data-kind="image"]')).toHaveCount(1);
+    await expect(composer.locator('.agent-attachment-card')).toHaveText(/狐狸照片\.png/);
+    await expect(send).toBeEnabled();
+    const confirms = (await operations(page)).filter(item => item?.operation === 'confirmAttachment');
+    expect(confirms).toHaveLength(1);
+    expect(confirms[0]?.input).toEqual({ thread_id: 'story-first', attachments: [{ object_name: 'temporary/狐狸照片.png', file_type: 'png' }] });
+    expect((await operations(page)).some(item => item?.operation === 'parseAttachment')).toBe(false);
+    await expectComposerBounds(page);
+    await screenshot(page, `agent-chat-inline-image-${width}`);
+    await remove.click();
+    await expect(composer.locator('.agent-attachment-selected')).toHaveCount(0);
+    await expect(send).toBeDisabled();
+    await composer.getByRole('button', { name: '对话文件', exact: true }).click();
+    await expect(composer.getByRole('checkbox', { name: '选择附件 狐狸照片.png', exact: true })).not.toBeChecked();
+    expect((await operations(page)).some(item => ['deleteAttachment', 'submit', 'preview'].includes(String(item?.operation)))).toBe(false);
+    expect(errors).toEqual([]);
+  });
+}
+
 test('running conversation keeps Stop reachable on a short narrow screen', async ({ page }) => {
   const errors = await openChat(page, 'running', 375, 540);
-  const stop = page.getByRole('button', { name: '停止', exact: true });
+  const stop = page.getByRole('button', { name: '停止回答', exact: true });
   await expect(stop).toBeInViewport({ ratio: 1 });
   await expectComposerBounds(page);
   await screenshot(page, 'agent-chat-running-375');
@@ -273,6 +339,92 @@ test('running conversation keeps Stop reachable on a short narrow screen', async
   expect(errors).toEqual([]);
 });
 
+for (const viewport of [{ width: 375, height: 540 }, { width: 1440, height: 900 }]) {
+  test(`reasoning streams separately and becomes collapsed durable history at ${viewport.width}×${viewport.height}`, async ({ page }) => {
+    const errors = await openChat(page, 'thinking', viewport.width, viewport.height);
+    const transcript = page.getByTestId('cloud-chat-messages');
+    const thinking = page.getByTestId('cloud-chat-reasoning');
+    const envelope = { thread_id: 'story-first', run_id: 'run-story-first' };
+    const prefix = '先观察故事里的小发现。\n';
+    const reasoning = prefix + Array.from({ length: 40 }, (_, index) =>
+      `第 ${index + 1} 个线索：${longWord}，再想一想角色会怎样解决。`).join('\n');
+    const answer = '小狐狸发现了会发光的故事笔记，决定邀请伙伴一起探索。';
+    const delta = (fields: Record<string, unknown>) => ({ stream_event: {
+      type: 'message_delta', message_id: 'assistant-story-first', ...fields,
+    } });
+    await expect.poll(() => page.evaluate(() => (window as unknown as FixtureWindow).__cloudChatFixture.streams.length)).toBe(1);
+    await expect(thinking).toHaveCount(0);
+
+    // Child Agent and unrelated run events never become visible in this chat.
+    for (const wrong of [{ thread_id: 'child-story', run_id: envelope.run_id }, { ...envelope, run_id: 'run-other' }]) {
+      await emitRunEvent(page, 'messages', '1000-0', { ...wrong, payload: { items: [delta({ reasoning_content: '不属于当前对话的思考' })] } });
+    }
+    await expect(thinking).toHaveCount(0);
+
+    await emitRunEvent(page, 'messages', '1001-0', { ...envelope, payload: { items: [delta({ reasoning_content: prefix })] } });
+    await expect(thinking).toHaveAttribute('open');
+    await expect(thinking).toContainText(prefix.trim());
+    await expect(page.locator('.agent-chat-welcome')).toHaveCount(0);
+    await expect(transcript.getByText(answer, { exact: true })).toHaveCount(0);
+
+    // Replayed SSE IDs must not duplicate the thought or replace the answer.
+    await emitRunEvent(page, 'messages', '1001-0', { ...envelope, payload: { items: [delta({ reasoning_content: '重复事件不应显示' })] } });
+    await emitRunEvent(page, 'messages', '1002-0', { ...envelope, payload: { chunk: delta({
+      additional_reasoning_content: reasoning.slice(prefix.length),
+    }) } });
+    await emitRunEvent(page, 'messages', '1003-0', { ...envelope, payload: { items: [delta({ content: answer })] } });
+    await expect(thinking).toContainText(reasoning);
+    await expect(transcript).not.toContainText('重复事件不应显示');
+    await expect(transcript).not.toContainText('不属于当前对话的思考');
+    await expect(transcript.getByText(answer, { exact: true })).toHaveCount(1);
+    expect(await thinking.locator('pre, table, a').count()).toBe(0);
+    await expectComposerBounds(page);
+    await screenshot(page, `agent-chat-reasoning-live-${viewport.width}`);
+
+    const durable = await page.evaluate(({ reasoning, answer, date }) => {
+      const state = (window as unknown as FixtureWindow).__cloudChatFixture;
+      const history = state.histories['story-first'];
+      if (!history.run) throw new Error('Missing reasoning fixture run');
+      history.run = { ...history.run, status: 'completed', output: answer };
+      history.messages = [{ id: 1, role: 'assistant', content: answer, reasoning_content: reasoning,
+        request_id: history.run.request_id, run_id: history.run.agent_run_id, created_at: date }];
+      state.threads[0] = { ...state.threads[0], status: 'completed' };
+      return { history, thread: state.threads[0] };
+    }, { reasoning, answer, date });
+    // Native terminal events can reuse the last message ID and still finish a run.
+    await emitRunEvent(page, 'end', '1003-0', { ...envelope, payload: { chunk: { status: 'completed' } } });
+    await expect(page.getByRole('button', { name: '停止回答', exact: true })).toHaveCount(0);
+    await expect(thinking).toHaveCount(1);
+    await expect(thinking).not.toHaveAttribute('open');
+    await expect(transcript.getByRole('article')).toHaveCount(1);
+    await expect(transcript.getByText(answer, { exact: true })).toHaveCount(1);
+    await thinking.locator('summary').scrollIntoViewIfNeeded();
+    await thinking.locator('summary').focus();
+    await page.keyboard.press('Enter');
+    await expect(thinking).toHaveAttribute('open');
+    await expect(thinking).toContainText(reasoning);
+    await expectComposerBounds(page);
+    await screenshot(page, `agent-chat-reasoning-history-${viewport.width}`);
+    await thinking.locator('summary').click();
+    await expect(thinking).not.toHaveAttribute('open');
+
+    // Reopening restores the durable conversation without bringing back history controls.
+    await page.evaluate(saved => sessionStorage.setItem('cloud-chat-fixture-durable', JSON.stringify(saved)), durable);
+    await page.reload();
+    await expect(thinking).toHaveCount(1);
+    await expect(thinking).not.toHaveAttribute('open');
+    await expect(page.getByRole('button', { name: '查看历史对话', exact: true })).toHaveCount(0);
+    await expect(page.getByLabel('历史对话', { exact: true })).toHaveCount(0);
+    await thinking.locator('summary').click();
+    await expect(thinking).toContainText(reasoning);
+    await expect(transcript.getByText(answer, { exact: true })).toHaveCount(1);
+    await expect(transcript.getByRole('article')).toHaveCount(1);
+    await expectComposerBounds(page);
+    expect((await operations(page)).some(item => ['submit', 'preview', 'resume'].includes(String(item?.operation)))).toBe(false);
+    expect(errors).toEqual([]);
+  });
+}
+
 test('approval details and decisions remain reachable without covering the composer', async ({ page }) => {
   const errors = await openChat(page, 'approval', 768, 480);
   const approval = page.getByRole('heading', { name: '需要你的确认', exact: true });
diff --git a/tests/e2e/cloud-agents.spec.ts b/tests/e2e/cloud-agents.spec.ts
index 763d74b5..bb52dbe4 100644
--- a/tests/e2e/cloud-agents.spec.ts
+++ b/tests/e2e/cloud-agents.spec.ts
@@ -91,7 +91,7 @@ test('personal cloud Agent identity, configuration and separate published chat i
             if (body.operation === 'submit' || body.operation === 'preview') return result({ request_id: input.request_id, thread_id: 'thread-1', run_id: 'run-1', version: '1', status: 'dispatched' });
             if (body.operation === 'history') return result({ thread_id: 'thread-1', next_offset: null,
               queued_requests: [], schedule_proposals: [{ id: 'proposal', name: '每天整理选题', prompt: '每天给我三个适合个人创作的选题', cron_expression: '30 8 * * *', timezone: 'Asia/Shanghai' }],
-              messages: [{ id: 1, role: 'assistant', content: '## 创作建议\n先从一个真实的观察开始。\n\n' + '记录今天的一次观察，把具体场景、你的感受和想分享的发现写下来。\n\n'.repeat(22) }],
+              messages: [{ id: 1, role: 'user', content: '先给我一些创作建议' }, { id: 2, role: 'assistant', content: '## 创作建议\n先从一个真实的观察开始。\n\n' + '记录今天的一次观察，把具体场景、你的感受和想分享的发现写下来。\n\n'.repeat(22) }],
               run: { agent_run_id: 'run-1', request_id: 'request-1', thread_id: 'thread-1', status: 'completed', version: '1' } });
             if (body.operation === 'viewed') return result({ viewed: true });
             if (body.operation === 'attachments') return result({ attachments: [] });
@@ -266,12 +266,17 @@ test('personal cloud Agent identity, configuration and separate published chat i
     expect(await messageOperations()).toEqual([]);
     await expect(formalChat.getByRole('heading', { name: 'Hi，今天想聊些什么？', exact: true })).toBeVisible();
     await expect(formalChat.locator('.agent-chat-welcome').getByRole('img', { name: '我的写作搭档头像', exact: true })).toHaveAttribute('src', avatar.icon_url);
-    const conversationSources = page.getByRole('navigation', { name: '对话来源', exact: true });
-    const sourceBounds = await conversationSources.getByRole('button', { name: '客户端对话', exact: true }).boundingBox();
-    const adjustBounds = await conversationSources.getByRole('button', { name: '调整智能体', exact: true }).boundingBox();
-    expect(sourceBounds).not.toBeNull();
-    expect(adjustBounds).not.toBeNull();
-    expect(Math.abs(sourceBounds!.y + sourceBounds!.height / 2 - adjustBounds!.y - adjustBounds!.height / 2)).toBeLessThanOrEqual(1);
+    const expectCleanChat = async () => {
+      await expect(page.getByRole('navigation', { name: '对话来源', exact: true })).toHaveCount(0);
+      await expect(page.getByRole('textbox', { name: '名称', exact: true })).toHaveCount(0);
+      await expect(page.getByRole('button', { name: /^(已保存|保存草稿|已应用|应用最新修改|调整智能体|修改头像|修改名称|查看历史对话|新对话|客户端对话|微信对话)$/ })).toHaveCount(0);
+      await expect(page.locator('.agent-chat-toolbar')).toHaveCount(0);
+      await expect(page.getByText('和助手聊一聊', { exact: true })).toHaveCount(0);
+      await expect(page.getByText(/由创建者支付词元点数/)).toHaveCount(0);
+    };
+    await expectCleanChat();
+    await expect(editor.locator('header').getByRole('heading', { name: '我的写作搭档', exact: true })).toBeVisible();
+    await expect(editor.locator('header').getByRole('img', { name: '我的写作搭档头像', exact: true })).toHaveAttribute('src', avatar.icon_url);
     const example = formalChat.locator('.agent-chat-example').first();
     const exampleText = await example.innerText();
     await example.click();
@@ -283,6 +288,14 @@ test('personal cloud Agent identity, configuration and separate published chat i
     await formalChat.getByRole('button', { name: '发送', exact: true }).click();
     await expect(formalChat.getByRole('heading', { name: '创作建议' })).toBeAttached();
     expect(await messageOperations()).toEqual(['submit']);
+    const userBubble = formalChat.locator('.agent-chat-message[data-role="user"]');
+    await expect(userBubble).toHaveText(/先给我一些创作建议/);
+    const bubbleStyle = await userBubble.evaluate(element => {
+      const style = getComputedStyle(element);
+      return { background: style.backgroundColor, radius: Number.parseFloat(style.borderTopLeftRadius) };
+    });
+    expect(bubbleStyle.background).not.toBe('rgba(0, 0, 0, 0)');
+    expect(bubbleStyle.radius).toBeGreaterThan(0);
     await expect(formalChat.locator('.agent-chat-message[data-role="assistant"]').getByRole('img', { name: '我的写作搭档头像', exact: true })).toHaveAttribute('src', avatar.icon_url);
     await expect(formalChat.getByLabel('消息', { exact: true })).toBeInViewport();
     const transcriptBounds = await formalChat.getByTestId('cloud-chat-messages').boundingBox();
@@ -294,7 +307,8 @@ test('personal cloud Agent identity, configuration and separate published chat i
     await app.evaluate(({ BrowserWindow }) => { const win = BrowserWindow.getAllWindows()[0]; win.setSize(980, 680); win.webContents.setZoomFactor(1.5); });
     await expect(formalChat.getByTestId('cloud-chat-composer')).toBeInViewport({ ratio: 1 });
     await expect(formalChat.getByRole('button', { name: '发送', exact: true })).toBeInViewport({ ratio: 1 });
-    await expect(conversationSources.getByRole('button', { name: '调整智能体', exact: true })).toBeInViewport({ ratio: 1 });
+    await expect(page.getByRole('button', { name: '返回智能体列表', exact: true })).toBeInViewport({ ratio: 1 });
+    await expectCleanChat();
     await expect.poll(() => editor.evaluate(el => el.scrollWidth - el.clientWidth)).toBeLessThanOrEqual(1);
     await expect.poll(() => formalChat.getByTestId('cloud-chat-messages').evaluate(el => el.clientHeight)).toBeGreaterThanOrEqual(80);
     // Chromium screenshots can crop a zoomed Electron surface. Capture the
@@ -305,7 +319,8 @@ test('personal cloud Agent identity, configuration and separate published chat i
     });
     await writeFile(testInfo.outputPath('cloud-agent-chat-compact-window.png'), Buffer.from(compactWindowImage, 'base64'));
     await app.evaluate(({ BrowserWindow }) => { const win = BrowserWindow.getAllWindows()[0]; win.webContents.setZoomFactor(1); win.setSize(1366, 768); });
-    await page.getByRole('button', { name: '调整智能体', exact: true }).click();
+    await page.getByRole('button', { name: '返回智能体列表', exact: true }).click();
+    await page.getByRole('article', { name: '我的写作搭档', exact: true }).getByRole('button', { name: '调整', exact: true }).click();
     await expect(prompt).toHaveValue(initialPrompt);
     await page.getByLabel('名称', { exact: true }).fill('我的新版写作搭档');
     await expect(page.getByRole('button', { name: '应用最新修改', exact: true })).toBeDisabled();
@@ -316,6 +331,7 @@ test('personal cloud Agent identity, configuration and separate published chat i
     await editor.getByRole('button', { name: '我的智能体', exact: true }).click();
     await page.getByRole('article', { name: '我的新版写作搭档', exact: true }).getByRole('button', { name: '和它聊聊', exact: true }).click();
     await expect(formalChat).toBeVisible();
+    await expectCleanChat();
     await expect(page.getByRole('button', { name: /^(聊天|自动任务|使用与接入)$/ })).toHaveCount(0);
     expect(await messageOperations()).toEqual(['submit']);
     await page.screenshot({ path: testInfo.outputPath('cloud-agent-separate-chat.png') });
diff --git a/tests/unit/cloud-agent-start-use.test.tsx b/tests/unit/cloud-agent-start-use.test.tsx
index 429e6774..6965682f 100644
--- a/tests/unit/cloud-agent-start-use.test.tsx
+++ b/tests/unit/cloud-agent-start-use.test.tsx
@@ -71,7 +71,11 @@ it('starts once from the saved configuration and opens conversation only after a
   fireEvent.click(screen.getByRole('button', { name: '继续编辑' }));
   await act(async () => finish({ version: 1, draft_revision: 3 }));
   expect(await screen.findByRole('region', { name: '智能体对话' })).toBeVisible();
-  expect(screen.getByRole('button', { name: '调整智能体', exact: true })).toBeVisible();
+  expect(screen.getByRole('heading', { name: '写作搭档', exact: true })).toBeVisible();
+  expect(screen.queryByLabelText('名称')).not.toBeInTheDocument();
+  for (const name of ['调整智能体', '已保存', '已应用', '应用最新修改']) {
+    expect(screen.queryByRole('button', { name, exact: true })).not.toBeInTheDocument();
+  }
   expect(api.save).not.toHaveBeenCalled();
   expect(messageOperations()).toHaveLength(0);
 });
@@ -166,6 +170,10 @@ it('keeps a newer saved revision unapplied when retry resolves the original unce
   const base = api.call.getMockImplementation()!;
   let attempts = 0;
   let activated = false;
+  let current = { ...draft, published_version: null as number | null };
+  api.list.mockImplementation(async () => ({ agents: [current], next_cursor: null }));
+  api.get.mockImplementation(async () => current);
+  api.save.mockImplementation(async (_slug, input) => (current = { ...current, ...input, draft_revision: 4 }));
   api.call.mockImplementation(async (operation, input) => {
     if (operation === 'access') return {
       published_version: activated ? 1 : null, enabled: true, grants: [], applications: [],
@@ -174,6 +182,7 @@ it('keeps a newer saved revision unapplied when retry resolves the original unce
     if (operation === 'publish') {
       if (++attempts === 1) throw new Error('连接中断');
       activated = true;
+      current = { ...current, published_version: 1 };
       return { version: 1, draft_revision: input.expected_revision };
     }
     return base(operation, input);
@@ -186,6 +195,9 @@ it('keeps a newer saved revision unapplied when retry resolves the original unce
   await waitFor(() => expect(screen.getByRole('button', { name: '已保存', exact: true })).toBeDisabled());
   fireEvent.click(screen.getByRole('button', { name: '重试开始使用', exact: true }));
   expect(await screen.findByRole('region', { name: '智能体对话' })).toBeVisible();
+  expect(screen.queryByRole('button', { name: '应用最新修改', exact: true })).not.toBeInTheDocument();
+  fireEvent.click(screen.getByRole('button', { name: '返回智能体列表', exact: true }));
+  fireEvent.click(await screen.findByRole('button', { name: '调整', exact: true }));
   await screen.findByText('修改已保存，尚未应用');
   expect(screen.getByText('这次修改还没有应用到正在使用的助手')).toBeVisible();
   expect(screen.getByRole('button', { name: '应用最新修改', exact: true })).toBeEnabled();
@@ -200,6 +212,8 @@ it('keeps a newer saved revision unapplied when retry resolves the original unce
 it('keeps successful activation and conversation when the following status read fails', async () => {
   const base = api.call.getMockImplementation()!;
   let activated = false;
+  api.list.mockImplementation(async () => ({ agents: [{ ...draft, published_version: activated ? 1 : null }], next_cursor: null }));
+  api.get.mockImplementation(async () => ({ ...draft, published_version: activated ? 1 : null }));
   api.call.mockImplementation(async (operation, input) => {
     if (operation === 'access' && activated) throw new Error('状态刷新失败');
     const result = await base(operation, input);
@@ -209,10 +223,15 @@ it('keeps successful activation and conversation when the following status read
   await openConfiguration();
   fireEvent.click(screen.getByRole('button', { name: '开始使用', exact: true }));
   expect(await screen.findByRole('region', { name: '智能体对话' })).toBeVisible();
+  await waitFor(() => expect(api.call.mock.calls.filter(([operation]) => operation === 'access')).toHaveLength(2));
+  expect(screen.queryByRole('button', { name: '已应用', exact: true })).not.toBeInTheDocument();
+  expect(screen.queryByRole('button', { name: '重试开始使用', exact: true })).not.toBeInTheDocument();
+  expect(screen.queryByText(/状态刷新失败/)).not.toBeInTheDocument();
+  fireEvent.click(screen.getByRole('button', { name: '返回智能体列表', exact: true }));
+  fireEvent.click(await screen.findByRole('button', { name: '调整', exact: true }));
   await screen.findByText(/状态刷新失败/);
-  expect(screen.getByRole('button', { name: '已应用', exact: true })).toBeDisabled();
   fireEvent.click(screen.getByRole('button', { name: '刷新应用状态', exact: true }));
-  await waitFor(() => expect(api.call.mock.calls.filter(([operation]) => operation === 'access')).toHaveLength(3));
+  await waitFor(() => expect(api.call.mock.calls.filter(([operation]) => operation === 'access')).toHaveLength(4));
   expect(publications()).toHaveLength(1);
   expect(messageOperations()).toHaveLength(0);
 });
diff --git a/tests/unit/cloud-agents-page.test.tsx b/tests/unit/cloud-agents-page.test.tsx
index 90866b87..00c9ca7f 100644
--- a/tests/unit/cloud-agents-page.test.tsx
+++ b/tests/unit/cloud-agents-page.test.tsx
@@ -87,23 +87,31 @@ it('shows saved but unapplied changes and applies directly from the editor heade
   expect(screen.getByRole('tab', { name: '介绍与提示词' })).toHaveAttribute('aria-selected', 'true');
 });
 
-it('keeps unsent input accessible before adjusting and applying configuration', async () => {
+it('keeps chat read-only and protects unsent input before returning to the card to configure', async () => {
   publishedAssistant(4);
   api.recovery.mockResolvedValue({ recent: null, pending: [] });
   open();
   fireEvent.click(await screen.findByRole('button', { name: '和它聊聊', exact: true }));
   await screen.findByTestId('cloud-agent-editor');
-  await waitFor(() => expect(screen.getByRole('button', { name: '已应用', exact: true })).toBeDisabled());
   const message = await screen.findByLabelText('消息');
   await waitFor(() => expect(message).toBeEnabled());
+  expect(screen.getByRole('heading', { name: '写作搭档', exact: true })).toBeVisible();
+  expect(screen.queryByLabelText('名称')).not.toBeInTheDocument();
+  expect(screen.queryByRole('navigation', { name: '对话来源' })).not.toBeInTheDocument();
+  for (const name of ['修改名称', '修改头像', '已保存', '保存草稿', '已应用', '应用最新修改', '调整智能体', '查看历史对话', '新对话']) {
+    expect(screen.queryByRole('button', { name, exact: true })).not.toBeInTheDocument();
+  }
   fireEvent.change(message, { target: { value: '保留正式聊天的问题' } });
-  fireEvent.click(screen.getByRole('button', { name: '调整智能体', exact: true }));
+  fireEvent.keyDown(window, { key: 's', ctrlKey: true });
+  expect(api.save).not.toHaveBeenCalled();
+  fireEvent.click(screen.getByRole('button', { name: '返回智能体列表', exact: true }));
+  expect(screen.getByRole('dialog', { name: '未保存的修改' })).toHaveTextContent('还有未发送的内容或未确认的操作');
+  fireEvent.click(screen.getByRole('button', { name: '继续编辑', exact: true }));
   expect(message).toBeVisible();
   expect(message).toHaveValue('保留正式聊天的问题');
-  expect(screen.getByText('对话中还有未完成的内容，请先发送或处理后再调整智能体。')).toBeVisible();
   fireEvent.change(message, { target: { value: '' } });
-  fireEvent.click(screen.getByRole('button', { name: '调整智能体', exact: true }));
-  expect(message).not.toBeVisible();
+  fireEvent.click(screen.getByRole('button', { name: '返回智能体列表', exact: true }));
+  fireEvent.click(await screen.findByRole('button', { name: '调整', exact: true }));
   fireEvent.change(screen.getByLabelText('提示词'), { target: { value: '新的要求' } });
   expect(screen.getByText('修改尚未保存和应用')).toBeVisible();
   expect(screen.getByRole('button', { name: '应用最新修改', exact: true })).toBeDisabled();
@@ -113,10 +121,12 @@ it('keeps unsent input accessible before adjusting and applying configuration',
   fireEvent.click(screen.getByRole('button', { name: '应用最新修改', exact: true }));
   await waitFor(() => expect(screen.getByRole('button', { name: '已应用', exact: true })).toBeDisabled());
   expect(screen.getByRole('tab', { name: '介绍与提示词' })).toHaveAttribute('aria-selected', 'true');
-  expect(screen.getByLabelText('消息')).toBe(message);
-  expect(message).not.toBeVisible();
-  expect(message).toHaveValue('');
-  expect(screen.queryByRole('button', { name: '聊天', exact: true })).not.toBeInTheDocument();
+  expect(screen.queryByLabelText('消息')).not.toBeInTheDocument();
+  fireEvent.click(screen.getByRole('button', { name: '我的智能体', exact: true }));
+  fireEvent.click(await screen.findByRole('button', { name: '和它聊聊', exact: true }));
+  await waitFor(() => expect(screen.getByLabelText('消息')).toBeEnabled());
+  expect(screen.getByLabelText('消息')).toHaveValue('');
+  expect(screen.queryByRole('button', { name: '已应用', exact: true })).not.toBeInTheDocument();
   expect(api.call.mock.calls.filter(([operation]) => operation === 'publish')[0][1]).toMatchObject({ expected_revision: 5 });
   expect(api.call.mock.calls.some(([operation]) => operation === 'preview' || operation === 'submit')).toBe(false);
 });
@@ -558,8 +568,10 @@ it('restores the exact previous thread and presents an uncertain operation witho
   });
   open();
   await screen.findByText('恢复了旧对话');
-  fireEvent.click(screen.getByRole('button', { name: '查看历史对话' }));
-  expect(screen.getByLabelText('历史对话')).toHaveValue('older-thread');
+  expect(api.call).toHaveBeenCalledWith('history', { thread_id: 'older-thread' });
+  expect(api.call.mock.calls.some(call => call[0] === 'history' && call[1].thread_id === 'newer-thread')).toBe(false);
+  expect(screen.queryByRole('button', { name: '查看历史对话' })).not.toBeInTheDocument();
+  expect(screen.queryByLabelText('历史对话')).not.toBeInTheDocument();
   expect(api.resolvePending).not.toHaveBeenCalled();
   expect(api.call.mock.calls.some(call => call[0] === 'submit')).toBe(false);
   api.resolvePending.mockResolvedValue({ result: { request_id: 'same-request', status: 'queued' } });
diff --git a/tests/unit/cloud-agents-workflows.test.tsx b/tests/unit/cloud-agents-workflows.test.tsx
index aa093aeb..0bb88bf9 100644
--- a/tests/unit/cloud-agents-workflows.test.tsx
+++ b/tests/unit/cloud-agents-workflows.test.tsx
@@ -59,7 +59,7 @@ it('recovers a server queue and cancels it after remount without resubmitting me
   expect(api.call.mock.calls.some(call => call[0] === 'submit')).toBe(false);
 });
 
-it('returns to the last selected thread on remount and requires restoring an archived conversation before sending', async () => {
+it('automatically restores the remembered thread and requires restoring archived conversations before sending', async () => {
   const base = api.call.getMockImplementation()!;
   const threads = ['newest', 'older'].map(id => ({ thread_id: id, client_thread_id: id, agent_slug: slug, mode: 'published' as const, title: id, status: 'idle', updated_at: '', run_id: null, unread: false }));
   let recent = { slug, mode: 'published' as const, thread_id: 'older' };
@@ -67,19 +67,20 @@ it('returns to the last selected thread on remount and requires restoring an arc
   api.remember.mockImplementation(async value => { recent = value; return { saved: true }; });
   api.call.mockImplementation(async (operation, input) => {
     if (operation === 'threads') return { threads, next_offset: null };
-    if (operation === 'history') return { thread_id: input.thread_id, messages: [], run: null, next_offset: null };
+    if (operation === 'history') return { thread_id: input.thread_id, messages: [{ id: 1, role: 'assistant', content: '保留的对话 ' + input.thread_id }], run: null, next_offset: null };
     if (operation === 'archiveThread') return { thread_id: input.thread_id, archived: false };
     return base(operation, input);
   });
   const first = render(<CloudChat slug={slug} />);
-  fireEvent.click(screen.getByRole('button', { name: '查看历史对话' }));
-  await waitFor(() => expect(screen.getByLabelText('历史对话')).toHaveValue('older'));
-  fireEvent.change(screen.getByLabelText('历史对话'), { target: { value: 'newest' } });
-  await waitFor(() => expect(recent.thread_id).toBe('newest'));
+  expect(await screen.findByText('保留的对话 older')).toBeVisible();
+  expect(api.call).toHaveBeenCalledWith('history', { thread_id: 'older' });
+  expect(screen.queryByRole('button', { name: '查看历史对话' })).not.toBeInTheDocument();
+  expect(screen.queryByRole('button', { name: '新对话' })).not.toBeInTheDocument();
   first.unmount();
+  recent = { ...recent, thread_id: 'newest' };
   const second = render(<CloudChat slug={slug} />);
-  fireEvent.click(screen.getByRole('button', { name: '查看历史对话' }));
-  await waitFor(() => expect(screen.getByLabelText('历史对话')).toHaveValue('newest'));
+  expect(await screen.findByText('保留的对话 newest')).toBeVisible();
+  expect(api.call).toHaveBeenCalledWith('history', { thread_id: 'newest' });
   second.unmount();
   recent = { ...recent, thread_id: 'older' };
   const beforeArchive = api.call.getMockImplementation()!;
@@ -157,13 +158,15 @@ it('retries the same request after a lost response and renders batched native SS
   const submissions = api.call.mock.calls.filter(call => call[0] === 'submit');
   expect(submissions[0][1]).toEqual(submissions[1][1]);
   await act(async () => stream.dispatchEvent(new MessageEvent('messages', {
-    data: JSON.stringify({ thread_id: 'thread-1', payload: { items: [
+    data: JSON.stringify({ run_id: 'run-1', thread_id: 'thread-1', payload: { items: [
       { stream_event: { type: 'message_delta', content: '第一段' } },
       { stream_event: { type: 'message_delta', content: '文字' } },
     ] } }),
   })));
   expect(screen.getByText('第一段文字')).toBeVisible();
-  expect(screen.getByText(/版本 2/)).toBeVisible();
+  expect(screen.queryByText(/版本 2/)).not.toBeInTheDocument();
+  expect(screen.queryByText('由创建者支付词元点数')).not.toBeInTheDocument();
+  expect(api.events).toHaveBeenCalledWith('run-1');
 });
 
 it('restores a durable question and follows the new resume run', async () => {
@@ -179,9 +182,9 @@ it('restores a durable question and follows the new resume run', async () => {
   });
   render(<CloudChat slug={slug} />);
   fireEvent.click(await screen.findByRole('radio', { name: '海洋' }));
-  fireEvent.click(screen.getByRole('button', { name: '新对话' }));
+  expect(screen.queryByRole('button', { name: '新对话' })).not.toBeInTheDocument();
+  expect(screen.queryByRole('button', { name: '查看历史对话' })).not.toBeInTheDocument();
   expect(screen.getByRole('radio', { name: '海洋' })).toBeChecked();
-  fireEvent.click(screen.getByRole('button', { name: '继续编辑' }));
   fireEvent.click(screen.getByRole('button', { name: '提交回答' }));
   await waitFor(() => expect(api.events).toHaveBeenCalledWith('run-2'));
   expect(api.call.mock.calls.find(call => call[0] === 'resume')?.[1].decision).toEqual({ direction: '海洋' });
@@ -340,41 +343,45 @@ it('keeps an unavailable existing notification target until the creator explicit
 
 
 
-it('returns to a newly created conversation from history without remounting the page', async () => {
+it('automatically restores a newly submitted conversation after remount without submitting it again', async () => {
   const base = api.call.getMockImplementation()!;
+  let created = false;
+  let recent = { slug, mode: 'published' as const, thread_id: '' };
+  api.recovery.mockImplementation(async () => ({ recent: recent.thread_id ? recent : null, pending: [] }));
+  api.remember.mockImplementation(async value => { recent = value; return { saved: true }; });
   api.call.mockImplementation(async (operation, input) => {
-    if (operation === 'submit') return { request_id: 'new-request', run_id: 'run-1', thread_id: 'thread-1', status: 'dispatched', version: '2' };
-    if (operation === 'history') return { ...history, run: { ...run, status: 'completed' } };
+    if (operation === 'threads') return { threads: created ? [{ thread_id: 'thread-1', client_thread_id: 'client', agent_slug: slug, title: '新对话主题', mode: 'published', status: 'completed', updated_at: '', run_id: 'run-1', unread: false }] : [], next_offset: null };
+    if (operation === 'submit') { created = true; return { request_id: 'new-request', run_id: 'run-1', thread_id: 'thread-1', status: 'dispatched', version: '2' }; }
+    if (operation === 'history') return { ...history, messages: [{ id: 1, role: 'user', content: '新对话主题' }], run: { ...run, status: 'completed' } };
     return base(operation, input);
   });
-  render(<CloudChat slug={slug} />);
+  const first = render(<CloudChat slug={slug} />);
   await waitFor(() => expect(screen.getByLabelText('消息')).not.toBeDisabled());
   fireEvent.change(screen.getByLabelText('消息'), { target: { value: '新对话主题' } });
   fireEvent.click(screen.getByRole('button', { name: '发送', exact: true }));
-  fireEvent.click(screen.getByRole('button', { name: '查看历史对话' }));
-  await waitFor(() => expect(screen.getByLabelText('历史对话')).toBeEnabled());
-  expect(screen.getByRole('option', { name: '新对话主题 · 已完成' })).toBeInTheDocument();
-  fireEvent.click(screen.getByRole('button', { name: '新对话' }));
-  expect(screen.getByLabelText('历史对话')).toHaveValue('');
-  fireEvent.change(screen.getByLabelText('历史对话'), { target: { value: 'thread-1' } });
-  await waitFor(() => expect(screen.getByLabelText('历史对话')).toHaveValue('thread-1'));
+  expect(await screen.findByText('新对话主题')).toBeVisible();
+  await waitFor(() => expect(recent.thread_id).toBe('thread-1'));
+  first.unmount();
+  render(<CloudChat slug={slug} />);
+  expect(await screen.findByText('新对话主题')).toBeVisible();
+  expect(screen.queryByLabelText('历史对话')).not.toBeInTheDocument();
+  expect(api.call.mock.calls.filter(call => call[0] === 'submit')).toHaveLength(1);
   expect(api.call.mock.calls.filter(call => call[0] === 'history' && call[1].thread_id === 'thread-1')).toHaveLength(2);
 });
 
-it('creates an attachment conversation only when the selected file is confirmed', async () => {
+it('creates an attachment conversation only after a native pick and deselects the inline file without deleting it', async () => {
   const base = api.call.getMockImplementation()!;
   api.call.mockImplementation(async (operation, input) => {
     if (operation === 'createThread') return { thread_id: 'thread-1', client_thread_id: input.thread_id };
-    if (operation === 'confirmAttachment') return { attachments: [{ file_id: 'attachment-1' }] };
+    if (operation === 'confirmAttachment') return { attachments: [{ file_id: 'attachment-1', file_name: 'notes.txt', file_size: 1024 }] };
     return base(operation, input);
   });
   api.upload.mockResolvedValueOnce(null).mockResolvedValueOnce({
     object_name: 'temporary/notes.txt', file_name: 'notes.txt', file_type: 'txt',
-    parse_supported: false, parse_methods: [],
+    parse_supported: true, parse_methods: ['disable', 'rapid_ocr'],
   });
   render(<CloudChat slug={slug} />);
-  fireEvent.click(screen.getByText('附件与产物'));
-  const add = screen.getByRole('button', { name: '添加附件' });
+  const add = screen.getByRole('button', { name: '添加文件或图片' });
   await waitFor(() => expect(add).toBeEnabled());
   fireEvent.click(add);
   await waitFor(() => expect(api.upload).toHaveBeenCalledTimes(1));
@@ -382,14 +389,117 @@ it('creates an attachment conversation only when the selected file is confirmed'
   expect(api.call.mock.calls.some(call => call[0] === 'createThread')).toBe(false);
   expect(screen.queryByLabelText('历史对话')).not.toBeInTheDocument();
   fireEvent.click(add);
-  const confirm = await screen.findByRole('button', { name: '加入此对话' });
-  expect(api.call.mock.calls.some(call => call[0] === 'createThread')).toBe(false);
-  fireEvent.click(confirm);
   await waitFor(() => expect(api.call).toHaveBeenCalledWith('confirmAttachment', {
     thread_id: 'thread-1', attachments: [{ object_name: 'temporary/notes.txt', file_type: 'txt' }],
   }));
   expect(api.call.mock.calls.filter(call => call[0] === 'createThread')).toHaveLength(1);
-  await waitFor(() => expect(screen.getByText('附件与产物 · 本条消息附带 1 个文件')).toBeVisible());
+  const remove = await screen.findByRole('button', { name: '移除附件 notes.txt' });
+  expect(remove.closest('[aria-label="本条消息的附件"]')).toBeInTheDocument();
+  await waitFor(() => expect(screen.getByRole('button', { name: '发送', exact: true })).toBeEnabled());
+  expect(api.call.mock.calls.some(call => call[0] === 'parseAttachment')).toBe(false);
+  fireEvent.click(remove);
+  expect(screen.queryByRole('button', { name: '移除附件 notes.txt' })).not.toBeInTheDocument();
+  expect(screen.getByRole('button', { name: '发送', exact: true })).toBeDisabled();
+  fireEvent.click(screen.getByRole('button', { name: '对话文件' }));
+  expect(await screen.findByRole('checkbox', { name: '选择附件 notes.txt' })).not.toBeChecked();
+  expect(api.call.mock.calls.some(call => ['deleteAttachment', 'submit', 'preview'].includes(call[0]))).toBe(false);
+});
+
+it('blocks preview switching while creating an attachment thread and ignores a late result after changing agents', async () => {
+  const base = api.call.getMockImplementation()!;
+  const nextSlug = 'ml-' + 'b'.repeat(32);
+  let finish!: (value: { thread_id: string; client_thread_id: string }) => void;
+  api.call.mockImplementation(async (operation, input) => {
+    if (operation === 'createThread') return new Promise(resolve => { finish = resolve; });
+    if (operation === 'threads') return { threads: input.slug === nextSlug ? [{ thread_id: 'new-agent-thread', client_thread_id: 'new-client', agent_slug: nextSlug, title: '另一个智能体的对话', mode: 'preview', draft_revision: 1, status: 'completed', updated_at: '', run_id: null, unread: false }] : [], next_offset: null };
+    if (operation === 'history') return { thread_id: input.thread_id, messages: [{ id: 1, role: 'assistant', content: '另一个智能体保留的回答' }], run: null, next_offset: null };
+    if (operation === 'preview') return { request_id: input.request_id, thread_id: input.thread_id, run_id: null, status: 'completed' };
+    return base(operation, input);
+  });
+  api.upload.mockResolvedValue({ object_name: 'temporary/old-agent-notes.txt', file_name: 'old-agent-notes.txt', file_type: 'txt', parse_supported: false, parse_methods: [] });
+  const view = render(<CloudChat slug={slug} previewRevision={1} />);
+  await waitFor(() => expect(screen.getByRole('button', { name: '添加文件或图片' })).toBeEnabled());
+  fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+  await waitFor(() => expect(api.call.mock.calls.filter(call => call[0] === 'createThread')).toHaveLength(1));
+  expect(screen.getByRole('button', { name: '新对话' })).toBeDisabled();
+  fireEvent.click(screen.getByRole('button', { name: '新对话' }));
+  expect(screen.queryByText('放弃未发送的内容并新建对话？')).not.toBeInTheDocument();
+  expect(api.call.mock.calls.some(call => call[0] === 'confirmAttachment')).toBe(false);
+  view.rerender(<CloudChat slug={nextSlug} previewRevision={1} />);
+  expect(await screen.findByText('另一个智能体保留的回答')).toBeVisible();
+  fireEvent.click(screen.getByRole('button', { name: '查看历史对话' }));
+  expect(screen.getByLabelText('历史对话')).toHaveValue('new-agent-thread');
+  await act(async () => finish({ thread_id: 'late-old-agent-thread', client_thread_id: 'old-client' }));
+  expect(screen.getByLabelText('历史对话')).toHaveValue('new-agent-thread');
+  expect(screen.queryByRole('option', { name: /late-old-agent-thread/ })).not.toBeInTheDocument();
+  expect(screen.queryByRole('button', { name: '移除附件 old-agent-notes.txt' })).not.toBeInTheDocument();
+  expect(api.call.mock.calls.some(call => call[0] === 'confirmAttachment')).toBe(false);
+  expect(api.remember.mock.calls.some(([value]) => value?.thread_id === 'late-old-agent-thread')).toBe(false);
+  fireEvent.change(screen.getByLabelText('消息'), { target: { value: '继续这个智能体的对话' } });
+  fireEvent.click(screen.getByRole('button', { name: '发送', exact: true }));
+  await waitFor(() => expect(api.call).toHaveBeenCalledWith('preview', expect.objectContaining({ slug: nextSlug, thread_id: 'new-agent-thread', expected_revision: 1, query: '继续这个智能体的对话', attachment_file_ids: [] })));
+});
+
+it('retries the same picked attachment and thread after confirmation fails, then sends that selection once', async () => {
+  const base = api.call.getMockImplementation()!;
+  let confirmations = 0;
+  api.call.mockImplementation(async (operation, input) => {
+    if (operation === 'createThread') return { thread_id: 'attachment-thread', client_thread_id: input.thread_id };
+    if (operation === 'confirmAttachment') {
+      if (++confirmations === 1) throw new Error('附件确认结果丢失');
+      return { attachments: [{ file_id: 'attachment-1', file_name: 'notes.txt', file_size: 1024 }] };
+    }
+    if (operation === 'submit') return { request_id: input.request_id, thread_id: 'attachment-thread', run_id: null, status: 'completed', version: '2' };
+    if (operation === 'history') return { thread_id: 'attachment-thread', messages: [], run: null, next_offset: null };
+    return base(operation, input);
+  });
+  api.upload.mockResolvedValue({ object_name: 'temporary/notes.txt', file_name: 'notes.txt', file_type: 'txt', parse_supported: false, parse_methods: [] });
+  render(<CloudChat slug={slug} />);
+  await waitFor(() => expect(screen.getByRole('button', { name: '添加文件或图片' })).toBeEnabled());
+  fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+  const retry = await screen.findByRole('button', { name: '重试添加' });
+  fireEvent.change(screen.getByLabelText('消息'), { target: { value: '请阅读这个附件' } });
+  expect(screen.getByRole('button', { name: '发送', exact: true })).toBeDisabled();
+  fireEvent.keyDown(screen.getByLabelText('消息'), { key: 'Enter' });
+  expect(api.call.mock.calls.some(call => call[0] === 'submit')).toBe(false);
+  fireEvent.change(screen.getByLabelText('消息'), { target: { value: '' } });
+  fireEvent.click(retry);
+  await screen.findByRole('button', { name: '移除附件 notes.txt' });
+  await waitFor(() => expect(screen.getByRole('button', { name: '发送', exact: true })).toBeEnabled());
+  const confirms = api.call.mock.calls.filter(call => call[0] === 'confirmAttachment');
+  expect(confirms).toHaveLength(2);
+  expect(confirms[1][1]).toEqual(confirms[0][1]);
+  expect(api.upload).toHaveBeenCalledTimes(1);
+  expect(api.call.mock.calls.filter(call => call[0] === 'createThread')).toHaveLength(1);
+  fireEvent.click(screen.getByRole('button', { name: '发送', exact: true }));
+  await waitFor(() => expect(api.call).toHaveBeenCalledWith('submit', expect.objectContaining({ slug, thread_id: 'attachment-thread', query: '请看看这些附件。', attachment_file_ids: ['attachment-1'] })));
+  expect(api.call.mock.calls.filter(call => call[0] === 'submit')).toHaveLength(1);
+  expect(api.call.mock.calls.some(call => call[0] === 'deleteAttachment')).toBe(false);
+});
+
+it('cancels an unconfirmed attachment without deleting it and permits the typed message to send', async () => {
+  const base = api.call.getMockImplementation()!;
+  api.call.mockImplementation(async (operation, input) => {
+    if (operation === 'createThread') return { thread_id: 'attachment-thread', client_thread_id: input.thread_id };
+    if (operation === 'confirmAttachment') throw new Error('附件确认结果丢失');
+    if (operation === 'submit') return { request_id: input.request_id, thread_id: 'attachment-thread', run_id: null, status: 'completed', version: '2' };
+    if (operation === 'history') return { thread_id: 'attachment-thread', messages: [], run: null, next_offset: null };
+    return base(operation, input);
+  });
+  api.upload.mockResolvedValue({ object_name: 'temporary/notes.txt', file_name: 'notes.txt', file_type: 'txt', parse_supported: false, parse_methods: [] });
+  render(<CloudChat slug={slug} />);
+  await waitFor(() => expect(screen.getByRole('button', { name: '添加文件或图片' })).toBeEnabled());
+  fireEvent.change(screen.getByLabelText('消息'), { target: { value: '继续讨论我的想法' } });
+  fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+  await screen.findByRole('button', { name: '重试添加' });
+  expect(screen.getByRole('button', { name: '发送', exact: true })).toBeDisabled();
+  fireEvent.click(screen.getByRole('button', { name: '取消添加' }));
+  await waitFor(() => expect(screen.getByRole('button', { name: '发送', exact: true })).toBeEnabled());
+  expect(screen.getByLabelText('消息')).toHaveValue('继续讨论我的想法');
+  fireEvent.click(screen.getByRole('button', { name: '发送', exact: true }));
+  await waitFor(() => expect(api.call).toHaveBeenCalledWith('submit', expect.objectContaining({ thread_id: 'attachment-thread', query: '继续讨论我的想法', attachment_file_ids: [] })));
+  expect(api.call.mock.calls.filter(call => call[0] === 'confirmAttachment')).toHaveLength(1);
+  expect(api.call.mock.calls.some(call => call[0] === 'deleteAttachment')).toBe(false);
 });
 
 
diff --git a/tests/unit/cloud-chat-reasoning.test.tsx b/tests/unit/cloud-chat-reasoning.test.tsx
new file mode 100644
index 00000000..66421c66
--- /dev/null
+++ b/tests/unit/cloud-chat-reasoning.test.tsx
@@ -0,0 +1,228 @@
+import type { ReactNode } from 'react';
+import { act, cleanup, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { CloudChat } from '@/pages/CloudAgents/CloudChat';
+import type { CloudHistory, CloudRun, CloudThread } from '../../shared/cloud-agents';
+
+const api = vi.hoisted(() => ({ call: vi.fn(), events: vi.fn(), remember: vi.fn(), recovery: vi.fn() }));
+vi.mock('@/lib/cloud-agents-api', () => ({ cloudAgentsApi: api }));
+vi.mock('@/pages/CloudAgents/CloudComposerAttachments', () => ({
+  CloudComposerAttachments: ({ children, footer }: { children?: ReactNode; footer?: ReactNode }) => <>{children}{footer}</>,
+}));
+class Stream extends EventTarget { close = vi.fn(); onopen = null; onerror = null; }
+const slug = 'ml-' + 'a'.repeat(32);
+const thread: CloudThread = { thread_id: 'thread-1', client_thread_id: 'thread-1', agent_slug: slug, title: '第一段', mode: 'published', updated_at: '', run_id: 'run-1', status: 'running', unread: false };
+const run: CloudRun = { agent_run_id: 'run-1', request_id: 'request-1', thread_id: 'thread-1', agent_slug: slug, status: 'running', output: '', version: '1' };
+let history: CloudHistory;
+let stream: Stream;
+const savedAssistant = (reasoning = '完整思考') => ({ id: 2, role: 'assistant' as const, content: '完整回答', reasoning_content: reasoning, request_id: 'request-1', run_id: 'run-1', created_at: '' });
+const emit = (fields: Record<string, unknown>, id = '1-0', type = 'messages', extra = {}) => act(async () => stream.dispatchEvent(new MessageEvent(type, {
+  lastEventId: id, data: JSON.stringify({ run_id: 'run-1', thread_id: 'thread-1', payload: { chunk: { stream_event: { type: 'message_delta', message_id: 'message-1', ...fields } } }, ...extra }),
+})));
+beforeEach(() => {
+  vi.resetAllMocks(); stream = new Stream();
+  history = { thread_id: 'thread-1', messages: [], run: { ...run }, next_offset: null };
+  api.events.mockResolvedValue(stream);
+  api.remember.mockResolvedValue({ saved: true }); api.recovery.mockResolvedValue({ recent: null, pending: [] });
+  api.call.mockImplementation(async (operation: string) => {
+    if (operation === 'threads') return { threads: [thread], next_offset: null };
+    if (operation === 'history') return structuredClone(history);
+    if (operation === 'viewed') return { viewed: true };
+    if (operation === 'run') return history.run;
+    throw new Error('Unexpected operation: ' + operation);
+  });
+});
+afterEach(() => { cleanup(); vi.useRealTimers(); });
+async function open(preview = false) {
+  render(<CloudChat slug={slug} previewRevision={preview ? 1 : undefined}
+    initialThread={preview ? { ...thread, mode: 'preview', draft_revision: 1 } : undefined} />);
+  await waitFor(() => expect(api.events).toHaveBeenCalledWith('run-1'));
+}
+
+it('shows reasoning without an answer, preserves manual folding during deltas and folds final history once', async () => {
+  await open(); await emit({ reasoning_content: '流式思考' });
+  const details = screen.getByTestId('cloud-chat-reasoning');
+  expect(details).toHaveAttribute('open'); expect(screen.queryByRole('heading', { name: 'Hi，今天想聊些什么？' })).not.toBeInTheDocument();
+  act(() => { details.removeAttribute('open'); fireEvent(details, new Event('toggle')); });
+  await emit({ reasoning_content: '第二段', content: '流式回答' }, '2-0');
+  expect(details).not.toHaveAttribute('open');
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('流式思考第二段');
+  expect(screen.getByText('流式回答')).toBeInTheDocument();
+  history = { ...history, run: { ...run, status: 'completed' }, messages: [savedAssistant()] };
+  await emit({}, '2-0', 'end');
+  await screen.findByText('完整回答');
+  expect(screen.getAllByTestId('cloud-chat-reasoning')).toHaveLength(1);
+  expect(screen.getByTestId('cloud-chat-reasoning')).not.toHaveAttribute('open');
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('完整思考');
+  expect(screen.queryByText('流式回答')).not.toBeInTheDocument();
+});
+
+it('keeps partial thought and answer when terminal history fails and excludes late other-thread events', async () => {
+  await open(); await emit({ reasoning_content: '已收思考', content: '已收片段' });
+  const base = api.call.getMockImplementation()!;
+  api.call.mockImplementation(async (operation, input) => operation === 'history' ? Promise.reject(new Error('历史暂时离线')) : base(operation, input));
+  await emit({}, '1-0', 'end');
+  await screen.findByText('历史暂时离线');
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('已收思考');
+  expect(screen.getByText('已收片段')).toBeInTheDocument();
+  expect(screen.getByTestId('cloud-chat-reasoning')).not.toHaveAttribute('open');
+  await emit({ reasoning_content: '另一线程' }, '2-0', 'messages', { thread_id: 'other-thread' });
+  expect(screen.getByLabelText('智能体思考过程')).not.toHaveTextContent('另一线程');
+});
+
+it('restores only assistant reasoning from completed history and shows no block for models without it', async () => {
+  history = { ...history, run: { ...run, status: 'completed' }, messages: [
+    { ...savedAssistant(), id: 1, role: 'user', reasoning_content: '不属于用户显示的思考', content: '用户问题' },
+    { ...savedAssistant(), id: 3, role: 'system', reasoning_content: '系统字段', content: '系统内容' },
+    savedAssistant(), { ...savedAssistant(''), id: 4, content: '没有思考的回答' },
+  ] };
+  render(<CloudChat slug={slug} />);
+  await screen.findByText('完整回答');
+  expect(screen.getAllByTestId('cloud-chat-reasoning')).toHaveLength(1);
+  expect(screen.getByTestId('cloud-chat-reasoning')).not.toHaveAttribute('open');
+  expect(screen.queryByText('不属于用户显示的思考')).not.toBeInTheDocument();
+  expect(screen.queryByText('系统字段')).not.toBeInTheDocument();
+  expect(api.events).not.toHaveBeenCalled();
+});
+
+it('clears live reasoning on a new conversation and ignores its obsolete stream', async () => {
+  await open(true); await emit({ reasoning_content: '旧对话思考' });
+  fireEvent.click(screen.getByRole('button', { name: '新对话' }));
+  await waitFor(() => expect(screen.queryByTestId('cloud-chat-reasoning')).not.toBeInTheDocument());
+  await emit({ reasoning_content: '旧事件迟到' }, '2-0');
+  expect(screen.queryByTestId('cloud-chat-reasoning')).not.toBeInTheDocument();
+  expect(api.call.mock.calls.some(call => ['submit', 'preview'].includes(call[0]))).toBe(false);
+});
+
+it('hydrates a final message that is saved after its terminal Run stops the running poll', async () => {
+  await open(); await emit({ reasoning_content: '还没落盘的思考', content: '还没落盘的回答' });
+  history = { ...history, run: { ...run, status: 'completed' } };
+  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval'] });
+  await emit({}, '1-0', 'end');
+  expect(screen.getByText('还没落盘的回答')).toBeInTheDocument();
+  history = { ...history, messages: [savedAssistant('迟到保存的思考')] };
+  await act(async () => { await vi.advanceTimersByTimeAsync(2000); });
+  expect(screen.getByText('完整回答')).toBeInTheDocument();
+  expect(screen.getAllByTestId('cloud-chat-reasoning')).toHaveLength(1);
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('迟到保存的思考');
+  expect(screen.queryByText('还没落盘的回答')).not.toBeInTheDocument();
+  expect(api.call.mock.calls.some(call => ['submit', 'preview'].includes(call[0]))).toBe(false);
+});
+
+it('ignores an obsolete terminal history response after a new request starts in the same thread', async () => {
+  await open(); await emit({ reasoning_content: '旧请求思考', content: '旧片段' });
+  history = { ...history, run: { ...run, status: 'completed' } };
+  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval'] });
+  await emit({}, '1-0', 'end');
+  let resolveOld!: (value: CloudHistory) => void;
+  const oldRead = new Promise<CloudHistory>(resolve => { resolveOld = resolve; });
+  const base = api.call.getMockImplementation()!;
+  let historyReads = 0;
+  api.call.mockImplementation(async (operation, input) => {
+    if (operation === 'history' && ++historyReads === 1) return oldRead;
+    if (operation === 'submit') return { request_id: 'request-2', run_id: 'run-2', thread_id: 'thread-1', status: 'running', version: '1' };
+    return base(operation, input);
+  });
+  await act(async () => { await vi.advanceTimersByTimeAsync(2000); });
+  const nextStream = new Stream(); api.events.mockResolvedValue(nextStream);
+  history = { ...history, run: { ...run, agent_run_id: 'run-2', request_id: 'request-2', status: 'running' } };
+  fireEvent.change(screen.getByLabelText('消息'), { target: { value: '新的问题' } });
+  await act(async () => { fireEvent.click(screen.getByRole('button', { name: '发送', exact: true })); });
+  await act(async () => nextStream.dispatchEvent(new MessageEvent('messages', { lastEventId: '2-0', data: JSON.stringify({
+    run_id: 'run-2', thread_id: 'thread-1', request_id: 'request-2', payload: { chunk: { stream_event: { type: 'message_delta', message_id: 'message-2', reasoning_content: '新请求思考' } } },
+  }) })));
+  await act(async () => { resolveOld({ ...history, run: { ...run, status: 'completed' }, messages: [savedAssistant()] }); });
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('新请求思考');
+  expect(screen.getByRole('button', { name: '停止回答', exact: true })).toBeInTheDocument();
+  expect(screen.queryByText('完整回答')).not.toBeInTheDocument();
+});
+
+it('ignores a pending history read when approval resumes the same request in a new Run', async () => {
+  await open(); await emit({ reasoning_content: '操作前的思考' });
+  await emit({}, '2-0', 'interrupt', { payload: { chunk: { approval: { action_requests: [{ name: 'execute', args: { command: 'fixture-only' } }] } } } });
+  let resolveOld!: (value: CloudHistory) => void;
+  const oldRead = new Promise<CloudHistory>(resolve => { resolveOld = resolve; });
+  const base = api.call.getMockImplementation()!;
+  const nextRun = { ...run, agent_run_id: 'run-2' };
+  api.call.mockImplementation(async (operation, input) => {
+    if (operation === 'history') return oldRead;
+    if (operation === 'resume') return { run_id: 'run-2', status: 'running' };
+    if (operation === 'run' && input.run_id === 'run-2') return nextRun;
+    return base(operation, input);
+  });
+  await emit({}, '2-0', 'end');
+  const nextStream = new Stream(); api.events.mockResolvedValue(nextStream);
+  await act(async () => { fireEvent.click(screen.getByRole('button', { name: '允许执行', exact: true })); });
+  await act(async () => nextStream.dispatchEvent(new MessageEvent('messages', { lastEventId: '1-0', data: JSON.stringify({
+    run_id: 'run-2', thread_id: 'thread-1', request_id: 'request-1', payload: { chunk: { stream_event: { type: 'message_delta', message_id: 'message-2', reasoning_content: '操作后的思考' } } },
+  }) })));
+  await act(async () => { resolveOld({ ...history, run: { ...run, status: 'interrupted' } }); });
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('操作前的思考');
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('操作后的思考');
+  expect(screen.queryByRole('button', { name: '允许执行', exact: true })).not.toBeInTheDocument();
+  expect(screen.getByRole('button', { name: '停止回答', exact: true })).toBeInTheDocument();
+});
+
+it('reopens a resumed same-Run stream and ignores its obsolete interrupted history response', async () => {
+  await open(); await emit({ reasoning_content: '操作前的思考', content: '操作前的片段' });
+  await emit({}, '2-0', 'interrupt', { payload: { chunk: { approval: { action_requests: [{ name: 'execute', args: { command: 'fixture-only' } }] } } } });
+  let resolveOld!: (value: CloudHistory) => void;
+  const oldRead = new Promise<CloudHistory>(resolve => { resolveOld = resolve; });
+  const base = api.call.getMockImplementation()!;
+  api.call.mockImplementation(async (operation, input) => {
+    if (operation === 'history') return oldRead;
+    if (operation === 'resume') return { run_id: 'run-1', status: 'running' };
+    if (operation === 'run' && input.run_id === 'run-1') return { ...run, status: 'running' };
+    return base(operation, input);
+  });
+  await emit({}, '2-0', 'end');
+  expect(screen.getByTestId('cloud-chat-reasoning')).not.toHaveAttribute('open');
+  const resumedStream = new Stream(); api.events.mockResolvedValue(resumedStream);
+  await act(async () => { fireEvent.click(screen.getByRole('button', { name: '允许执行', exact: true })); });
+  await waitFor(() => expect(api.events).toHaveBeenLastCalledWith('run-1', '2-0'));
+  expect(api.events).toHaveBeenCalledTimes(2);
+  await act(async () => resumedStream.dispatchEvent(new MessageEvent('messages', { lastEventId: '3-0', data: JSON.stringify({
+    run_id: 'run-1', thread_id: 'thread-1', request_id: 'request-1', payload: { chunk: { stream_event: {
+      type: 'message_delta', message_id: 'message-2', reasoning_content: '恢复后的思考', content: '恢复后的回答',
+    } } },
+  }) })));
+  expect(screen.getByTestId('cloud-chat-reasoning')).toHaveAttribute('open');
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('操作前的思考');
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('恢复后的思考');
+  expect(screen.getByText(/恢复后的回答/)).toBeInTheDocument();
+  await act(async () => { resolveOld({ ...history, run: { ...run, status: 'interrupted' }, messages: [savedAssistant()] }); });
+  expect(screen.getByLabelText('智能体思考过程')).toHaveTextContent('恢复后的思考');
+  expect(screen.getByTestId('cloud-chat-reasoning')).toHaveAttribute('open');
+  expect(screen.getByRole('button', { name: '停止回答', exact: true })).toBeInTheDocument();
+  expect(screen.queryByRole('button', { name: '允许执行', exact: true })).not.toBeInTheDocument();
+  expect(screen.queryByText('完整回答')).not.toBeInTheDocument();
+  expect(resumedStream.close).not.toHaveBeenCalled();
+  expect(api.call.mock.calls.some(call => ['submit', 'preview'].includes(call[0]))).toBe(false);
+});
+
+it('ignores a late approval receipt after the user discards input and starts a new conversation', async () => {
+  await open(true); await emit({ reasoning_content: '离开前的思考' });
+  await emit({}, '2-0', 'interrupt', { payload: { chunk: { approval: { action_requests: [{ name: 'execute', args: { command: 'fixture-only' } }] } } } });
+  let resolveResume!: (value: { run_id: string; status: string }) => void;
+  const pendingResume = new Promise<{ run_id: string; status: string }>(resolve => { resolveResume = resolve; });
+  const base = api.call.getMockImplementation()!;
+  api.call.mockImplementation(async (operation, input) => {
+    if (operation === 'resume') return pendingResume;
+    if (operation === 'run' && input.run_id === 'resumed-old-run') return { ...run, agent_run_id: 'resumed-old-run' };
+    return base(operation, input);
+  });
+  fireEvent.click(screen.getByRole('button', { name: '允许执行', exact: true }));
+  await waitFor(() => expect(api.call.mock.calls.some(([operation]) => operation === 'resume')).toBe(true));
+  fireEvent.click(screen.getByRole('button', { name: '新对话', exact: true }));
+  fireEvent.click(await screen.findByRole('button', { name: '放弃内容', exact: true }));
+  expect(screen.queryByTestId('cloud-chat-reasoning')).not.toBeInTheDocument();
+  expect(screen.getByRole('heading', { name: '问它一个小问题' })).toBeInTheDocument();
+  await act(async () => { resolveResume({ run_id: 'resumed-old-run', status: 'running' }); });
+  expect(screen.queryByRole('button', { name: '停止回答', exact: true })).not.toBeInTheDocument();
+  expect(screen.queryByRole('button', { name: '允许执行', exact: true })).not.toBeInTheDocument();
+  expect(screen.queryByTestId('cloud-chat-reasoning')).not.toBeInTheDocument();
+  expect(screen.getByRole('heading', { name: '问它一个小问题' })).toBeInTheDocument();
+  expect(api.events).not.toHaveBeenCalledWith('resumed-old-run');
+  expect(api.events).toHaveBeenCalledTimes(1);
+  expect(api.call.mock.calls.some(call => ['submit', 'preview'].includes(call[0]))).toBe(false);
+});
diff --git a/tests/unit/cloud-chat-stream.test.ts b/tests/unit/cloud-chat-stream.test.ts
new file mode 100644
index 00000000..e482aa31
--- /dev/null
+++ b/tests/unit/cloud-chat-stream.test.ts
@@ -0,0 +1,54 @@
+import { describe, expect, it } from 'vitest';
+import { consumeCloudChatEvent, type CloudChatStream } from '@/pages/CloudAgents/cloud-chat-stream';
+
+const envelope = (items: unknown[], extra = {}) => ({ run_id: 'run-1', thread_id: 'thread-1', request_id: 'request-1', payload: { items }, ...extra });
+const delta = (fields = {}) => ({ stream_event: { type: 'message_delta', message_id: 'message-1', ...fields } });
+const consume = (state: CloudChatStream | null, value: unknown, id = '1-0', type = 'messages') =>
+  consumeCloudChatEvent(state, value, type, id, 'run-1', 'thread-1', 'request-1');
+
+describe('personal Agent main-thread stream projection', () => {
+  it('separates reasoning and answers in batched and single chunks with legacy fallback', () => {
+    let state = consume(null, envelope([delta({ reasoning_content: '思考一', additional_reasoning_content: '不应重复', content: '回答一' })]));
+    state = consume(state, { run_id: 'run-1', thread_id: 'thread-1', payload: { chunk: delta({ additional_reasoning_content: '思考二', content: '回答二' }) } }, '2-0');
+    expect(state).toMatchObject({ reasoning: '思考一思考二', content: '回答一回答二', cursor: '2-0' });
+    expect(JSON.stringify(state)).not.toContain('不应重复');
+  });
+
+  it('separates model messages across tool steps without treating tools as reasoning', () => {
+    const state = consume(null, envelope([
+      delta({ reasoning_content: '先看资料', content: '第一段' }),
+      { stream_event: { type: 'tool_call', name: 'search', arguments: 'private tool args' } },
+      delta({ message_id: 'message-2', reasoning_content: '核对资料', content: '第二段' }),
+    ]));
+    expect(state).toMatchObject({ reasoning: '先看资料\n\n核对资料', content: '第一段\n\n第二段', toolName: 'search' });
+    expect(JSON.stringify(state)).not.toContain('private tool args');
+  });
+
+  it('ignores other Runs/requests and excludes absent or child thread identities while advancing the cursor', () => {
+    const state = consume(null, envelope([delta({ reasoning_content: '父线程' })]));
+    expect(consume(state, envelope([delta({ reasoning_content: '另一个运行' })], { run_id: 'run-2' }), '2-0')).toBe(state);
+    expect(consume(state, envelope([delta({ reasoning_content: '另一个请求' })], { request_id: 'request-2' }), '2-0')).toBe(state);
+    const child = consume(state, envelope([delta({ reasoning_content: '子线程' })], { thread_id: 'child-thread' }), '2-0');
+    const missing = consume(child, envelope([delta({ content: '缺身份' })], { thread_id: undefined }), '3-0');
+    expect(missing).toMatchObject({ reasoning: '父线程', content: '', cursor: '3-0', ended: false });
+    expect(consume(missing, envelope([], { thread_id: 'child-thread' }), '4-0', 'end')).toMatchObject({ ended: false });
+  });
+
+  it('deduplicates replayed/out-of-order message IDs with exact large Redis IDs but accepts terminal reuse', () => {
+    const state = consume(null, envelope([delta({ reasoning_content: '一次' })]), '99999999999999999999-1');
+    expect(consume(state, envelope([delta({ reasoning_content: '重放' })]), '99999999999999999999-1')).toBe(state);
+    expect(consume(state, envelope([delta({ reasoning_content: '迟到' })]), '99999999999999999998-99')).toBe(state);
+    const next = consume(state, envelope([delta({ reasoning_content: '二次' })]), '99999999999999999999-2');
+    expect(consume(next, envelope([]), '99999999999999999999-2', 'end')).toMatchObject({ reasoning: '一次二次', ended: true });
+  });
+
+  it('keeps missing-ID compatibility and retains same-request reasoning over a resumed Run only', () => {
+    const first = consume(null, envelope([delta({ reasoning_content: '之前', content: '旧预览' })]), '');
+    const next = consumeCloudChatEvent(first, envelope([delta({ message_id: 'message-2', reasoning_content: '继续', content: '新预览' })], { run_id: 'run-2' }),
+      'messages', '1-0', 'run-2', 'thread-1', 'request-1');
+    expect(next).toMatchObject({ cursor: '1-0', reasoning: '之前\n\n继续', content: '新预览', ended: false });
+    const other = consumeCloudChatEvent(next, envelope([delta({ reasoning_content: '新问题' })], { run_id: 'run-3', request_id: 'request-3' }),
+      'messages', '1-0', 'run-3', 'thread-1', 'request-3');
+    expect(other).toMatchObject({ reasoning: '新问题', content: '' });
+  });
+});
diff --git a/tests/unit/cloud-composer-attachments.test.tsx b/tests/unit/cloud-composer-attachments.test.tsx
new file mode 100644
index 00000000..b0389990
--- /dev/null
+++ b/tests/unit/cloud-composer-attachments.test.tsx
@@ -0,0 +1,316 @@
+import { useState } from 'react';
+import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { CloudComposerAttachments } from '@/pages/CloudAgents/CloudComposerAttachments';
+import { CloudPendingContext } from '@/pages/CloudAgents/CloudPending';
+import type { CloudAttachment, CloudUpload } from '../../shared/cloud-agents';
+
+const api = vi.hoisted(() => ({ call: vi.fn(), upload: vi.fn(), download: vi.fn() }));
+vi.mock('@/lib/cloud-agents-api', () => ({ cloudAgentsApi: api }));
+
+const photo: CloudAttachment = { file_id: 'photo-id', file_name: '我的画.png', file_size: 8192, path: '/attachments/photo', original_path: '/original/photo' };
+const document: CloudAttachment = { file_id: 'document-id', file_name: '故事.docx', file_size: 1200, path: '/attachments/story', original_path: '/original/story' };
+const upload: CloudUpload = { object_name: 'temporary/photo-object', file_name: photo.file_name, file_type: 'image/png', parse_supported: true, parse_methods: ['disable', 'rapid_ocr'] };
+
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (error: Error) => void;
+  const promise = new Promise<T>((done, fail) => { resolve = done; reject = fail; });
+  return { promise, resolve, reject };
+}
+
+function operationCalls(operation: string) {
+  return api.call.mock.calls.filter(([name]) => name === operation);
+}
+
+function open({ initialSelected = [], threadId, disabled = false, ensureThread = vi.fn().mockResolvedValue('thread-created') }: {
+  initialSelected?: string[]; threadId?: string; disabled?: boolean; ensureThread?: () => Promise<string>;
+} = {}) {
+  const onBusy = vi.fn();
+  const onSelected = vi.fn();
+  const pending = vi.fn();
+  const submit = vi.fn();
+  function Harness({ disabled, threadId }: { disabled: boolean; threadId?: string }) {
+    const [selected, setSelected] = useState(initialSelected);
+    const [text, setText] = useState('保留这些文字');
+    return <CloudPendingContext.Provider value={pending}><form onSubmit={event => { event.preventDefault(); submit(); }}>
+      <CloudComposerAttachments threadId={threadId} disabled={disabled} ensureThread={ensureThread} selected={selected} onBusy={onBusy}
+        onSelected={value => { onSelected(value); setSelected(value); }} footer={<span data-testid="composer-footer">发送区</span>}>
+        <textarea aria-label="消息" value={text} onChange={event => setText(event.target.value)} />
+      </CloudComposerAttachments>
+    </form></CloudPendingContext.Provider>;
+  }
+  const view = render(<Harness disabled={disabled} threadId={threadId} />);
+  const hasPending = () => [...new Map(pending.mock.calls.map(([id, value]) => [id, value])).values()].some(Boolean);
+  return { ...view, onBusy, onSelected, pending, submit, ensureThread, hasPending,
+    update: (next: { disabled?: boolean; threadId?: string }) => view.rerender(<Harness disabled={next.disabled ?? disabled} threadId={next.threadId} />),
+  };
+}
+
+beforeEach(() => {
+  vi.resetAllMocks();
+  api.upload.mockResolvedValue(upload);
+  api.download.mockResolvedValue({ saved: true });
+  api.call.mockImplementation(async (operation: string) => {
+    if (operation === 'attachments') return { attachments: [] };
+    if (operation === 'files') return { files: [] };
+    if (operation === 'confirmAttachment') return { attachments: [photo] };
+    if (operation === 'parseAttachment') return { parsed_object_name: 'temporary/parsed-object' };
+    throw new Error('Unexpected operation: ' + operation);
+  });
+});
+afterEach(cleanup);
+
+describe('CloudComposerAttachments', () => {
+  it.each([
+    { file: photo, type: 'image/png', kind: 'image', label: '图片文件' },
+    { file: document, type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document', kind: 'file', label: '文件' },
+  ])('adds a $kind file directly with the original reading method', async ({ file, type, kind, label }) => {
+    api.upload.mockResolvedValue({ ...upload, file_name: file.file_name, file_type: type });
+    const base = api.call.getMockImplementation()!;
+    api.call.mockImplementation(async (operation, input) => operation === 'confirmAttachment' ? { attachments: [file] } : base(operation, input));
+    const view = open({ initialSelected: ['existing-id'] });
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    const chip = await screen.findByRole('button', { name: '移除附件 ' + file.file_name });
+    expect(chip.closest('.agent-attachment-card')).toHaveAttribute('data-kind', kind);
+    expect(within(chip.closest('.agent-attachment-card') as HTMLElement).getByLabelText(label)).toBeInTheDocument();
+    expect(screen.queryByRole('img')).not.toBeInTheDocument();
+    expect(view.onSelected).toHaveBeenLastCalledWith(['existing-id', file.file_id]);
+    expect(operationCalls('confirmAttachment')).toEqual([['confirmAttachment', { thread_id: 'thread-created', attachments: [{ object_name: upload.object_name, file_type: type }] }]]);
+    expect(operationCalls('parseAttachment')).toHaveLength(0);
+    expect(view.ensureThread).toHaveBeenCalledTimes(1);
+    expect(view.onBusy.mock.calls).toEqual([[true], [false]]);
+    await waitFor(() => expect(view.hasPending()).toBe(false));
+    expect(screen.getByLabelText('消息')).toHaveValue('保留这些文字');
+    expect(screen.getByTestId('composer-footer').closest('.agent-attachment-toolbar')).toContainElement(screen.getByRole('button', { name: '添加文件或图片' }));
+    for (const button of screen.getAllByRole('button')) expect(button).toHaveAttribute('type', 'button');
+    expect(view.submit).not.toHaveBeenCalled();
+  });
+
+  it('does not create a conversation or change existing input when the native picker is canceled', async () => {
+    api.upload.mockResolvedValue(null);
+    const view = open({ initialSelected: ['existing-id'] });
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    await waitFor(() => expect(view.onBusy).toHaveBeenLastCalledWith(false));
+    expect(view.ensureThread).not.toHaveBeenCalled();
+    expect(operationCalls('confirmAttachment')).toHaveLength(0);
+    expect(view.onSelected).not.toHaveBeenCalled();
+    expect(screen.getByLabelText('消息')).toHaveValue('保留这些文字');
+    expect(view.hasPending()).toBe(false);
+  });
+
+  it('retains the uploaded object and resolved conversation for an explicit confirmation retry', async () => {
+    const base = api.call.getMockImplementation()!;
+    let attempt = 0;
+    api.call.mockImplementation(async (operation, input) => {
+      if (operation === 'confirmAttachment' && ++attempt === 1) throw new Error('确认时连接中断');
+      return base(operation, input);
+    });
+    const view = open({ initialSelected: ['existing-id'] });
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    expect(await screen.findByRole('alert')).toHaveTextContent('确认时连接中断');
+    expect(view.hasPending()).toBe(true);
+    expect(view.onBusy).toHaveBeenLastCalledWith(false);
+    expect(view.onSelected).not.toHaveBeenCalled();
+    expect(screen.getByRole('button', { name: '添加文件或图片' })).toBeDisabled();
+    fireEvent.change(screen.getByLabelText('消息'), { target: { value: '失败后还可以继续写' } });
+    fireEvent.click(screen.getByRole('button', { name: '重试添加' }));
+    await screen.findByRole('button', { name: '移除附件 ' + photo.file_name });
+    expect(api.upload).toHaveBeenCalledTimes(1);
+    expect(view.ensureThread).toHaveBeenCalledTimes(1);
+    const attempts = operationCalls('confirmAttachment');
+    expect(attempts).toHaveLength(2);
+    expect(attempts[1]).toEqual(attempts[0]);
+    expect(view.onSelected).toHaveBeenLastCalledWith(['existing-id', photo.file_id]);
+    expect(screen.getByLabelText('消息')).toHaveValue('失败后还可以继续写');
+    expect(view.hasPending()).toBe(false);
+  });
+
+  it('keeps the picked object when ensuring the conversation fails and cancels without deleting files', async () => {
+    const ensureThread = vi.fn().mockRejectedValueOnce(new Error('对话暂时无法创建')).mockResolvedValue('same-client-thread');
+    const view = open({ ensureThread, initialSelected: ['existing-id'] });
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    await screen.findByText('对话暂时无法创建');
+    expect(view.hasPending()).toBe(true);
+    fireEvent.click(screen.getByRole('button', { name: '重试添加' }));
+    await screen.findByRole('button', { name: '移除附件 ' + photo.file_name });
+    expect(api.upload).toHaveBeenCalledTimes(1);
+    expect(operationCalls('confirmAttachment')[0][1]).toMatchObject({ thread_id: 'same-client-thread' });
+    api.call.mockImplementation(async (operation: string) => {
+      if (operation === 'confirmAttachment') throw new Error('第二个文件未确认');
+      return operation === 'attachments' ? { attachments: [photo] } : { files: [] };
+    });
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    await screen.findByText('第二个文件未确认');
+    fireEvent.click(screen.getByRole('button', { name: '取消添加' }));
+    expect(screen.queryByRole('button', { name: '重试添加' })).not.toBeInTheDocument();
+    expect(view.hasPending()).toBe(false);
+    expect(view.onSelected).toHaveBeenLastCalledWith(['existing-id', photo.file_id]);
+    expect(operationCalls('deleteAttachment')).toHaveLength(0);
+  });
+
+  it('only deselects a removed chip and can select the uploaded file again', async () => {
+    api.call.mockImplementation(async (operation: string) => operation === 'attachments' ? { attachments: [photo, document] } : { files: [] });
+    const view = open({ threadId: 'thread-existing', initialSelected: [photo.file_id] });
+    fireEvent.click(await screen.findByRole('button', { name: '移除附件 ' + photo.file_name }));
+    expect(view.onSelected).toHaveBeenLastCalledWith([]);
+    expect(operationCalls('deleteAttachment')).toHaveLength(0);
+    fireEvent.click(screen.getByRole('button', { name: '对话文件' }));
+    const choice = await screen.findByRole('checkbox', { name: '选择附件 ' + photo.file_name });
+    expect(choice).not.toBeChecked();
+    fireEvent.click(choice);
+    expect(view.onSelected).toHaveBeenLastCalledWith([photo.file_id]);
+    expect(screen.getByRole('button', { name: '移除附件 ' + photo.file_name })).toBeInTheDocument();
+    expect(api.upload).not.toHaveBeenCalled();
+    expect(view.ensureThread).not.toHaveBeenCalled();
+  });
+
+  it('prevents duplicate picker and confirmation calls while an operation is busy', async () => {
+    const picker = deferred<CloudUpload | null>();
+    const confirmation = deferred<{ attachments: CloudAttachment[] }>();
+    api.upload.mockReturnValue(picker.promise);
+    const base = api.call.getMockImplementation()!;
+    api.call.mockImplementation((operation, input) => operation === 'confirmAttachment' ? confirmation.promise : base(operation, input));
+    const view = open();
+    const add = screen.getByRole('button', { name: '添加文件或图片' });
+    fireEvent.click(add); fireEvent.click(add);
+    expect(api.upload).toHaveBeenCalledTimes(1);
+    expect(add).toBeDisabled();
+    expect(screen.getByLabelText('消息')).toBeEnabled();
+    await act(async () => { picker.resolve(upload); });
+    await waitFor(() => expect(operationCalls('confirmAttachment')).toHaveLength(1));
+    fireEvent.click(add);
+    expect(api.upload).toHaveBeenCalledTimes(1);
+    await act(async () => { confirmation.resolve({ attachments: [photo] }); });
+    await screen.findByRole('button', { name: '移除附件 ' + photo.file_name });
+    expect(view.onSelected).toHaveBeenCalledTimes(1);
+    expect(view.onBusy.mock.calls).toEqual([[true], [false]]);
+  });
+
+  it('does not add, remove or select attachments when disabled', async () => {
+    api.call.mockImplementation(async (operation: string) => operation === 'attachments' ? { attachments: [photo] } : { files: [] });
+    const view = open({ threadId: 'thread-existing', disabled: true, initialSelected: [photo.file_id] });
+    const remove = await screen.findByRole('button', { name: '移除附件 ' + photo.file_name });
+    expect(remove).toBeDisabled();
+    fireEvent.click(remove);
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    fireEvent.click(screen.getByRole('button', { name: '对话文件' }));
+    const choice = screen.getByRole('checkbox', { name: '选择附件 ' + photo.file_name });
+    expect(choice).toBeDisabled();
+    fireEvent.click(choice);
+    await screen.findByText('还没有生成文件。');
+    expect(api.upload).not.toHaveBeenCalled();
+    expect(view.onSelected).not.toHaveBeenCalled();
+  });
+
+  it('releases busy and pending state on unmount and ignores a later picker response', async () => {
+    const picker = deferred<CloudUpload | null>();
+    api.upload.mockReturnValue(picker.promise);
+    const view = open();
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    expect(view.hasPending()).toBe(true);
+    view.unmount();
+    expect(view.onBusy.mock.calls).toEqual([[true], [false]]);
+    expect(view.hasPending()).toBe(false);
+    await act(async () => { picker.resolve(upload); });
+    expect(view.ensureThread).not.toHaveBeenCalled();
+    expect(operationCalls('confirmAttachment')).toHaveLength(0);
+    expect(view.onSelected).not.toHaveBeenCalled();
+  });
+
+  it('ignores a confirmation response after unmount without replacing selected input', async () => {
+    const confirmation = deferred<{ attachments: CloudAttachment[] }>();
+    const base = api.call.getMockImplementation()!;
+    api.call.mockImplementation((operation, input) => operation === 'confirmAttachment' ? confirmation.promise : base(operation, input));
+    const view = open();
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    await waitFor(() => expect(operationCalls('confirmAttachment')).toHaveLength(1));
+    view.unmount();
+    await act(async () => { confirmation.resolve({ attachments: [photo] }); });
+    expect(view.onSelected).not.toHaveBeenCalled();
+    expect(view.onBusy.mock.calls).toEqual([[true], [false]]);
+    expect(view.hasPending()).toBe(false);
+  });
+
+  it('shows a loading error without a false empty state and restores long names on refresh', async () => {
+    const list = deferred<{ attachments: CloudAttachment[] }>();
+    const longName = '小朋友写的故事'.repeat(30) + '.docx';
+    const longFile = { ...document, file_name: longName };
+    let reads = 0;
+    api.call.mockImplementation(async (operation: string) => {
+      if (operation === 'attachments') return ++reads === 1 ? list.promise : { attachments: [longFile] };
+      return { files: [] };
+    });
+    const view = open({ threadId: 'thread-existing', initialSelected: [document.file_id] });
+    fireEvent.click(screen.getByRole('button', { name: '对话文件' }));
+    expect(screen.getByText('正在读取文件…')).toBeInTheDocument();
+    await act(async () => { list.reject(new Error('文件读取失败')); });
+    expect(await screen.findByRole('alert')).toHaveTextContent('文件读取失败');
+    expect(screen.queryByText('还没有上传文件。')).not.toBeInTheDocument();
+    expect(view.onSelected).not.toHaveBeenCalled();
+    fireEvent.click(screen.getByRole('button', { name: '刷新文件' }));
+    const remove = await screen.findByRole('button', { name: '移除附件 ' + longName });
+    expect(within(remove.closest('.agent-attachment-card') as HTMLElement).getByTitle(longName)).toHaveClass('agent-attachment-name');
+    expect(screen.getByRole('checkbox', { name: '选择附件 ' + longName })).toBeChecked();
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    expect(view.submit).not.toHaveBeenCalled();
+  });
+
+  it('lets the user retry or cancel a picker failure without touching existing input', async () => {
+    api.upload.mockRejectedValueOnce(new Error('上传失败')).mockResolvedValue(null);
+    const view = open({ initialSelected: ['existing-id'] });
+    fireEvent.click(screen.getByRole('button', { name: '添加文件或图片' }));
+    await screen.findByText('上传失败');
+    fireEvent.click(screen.getByRole('button', { name: '重试选择文件' }));
+    await waitFor(() => expect(api.upload).toHaveBeenCalledTimes(2));
+    await waitFor(() => expect(view.onBusy).toHaveBeenLastCalledWith(false));
+    expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+    expect(view.onSelected).not.toHaveBeenCalled();
+    expect(view.ensureThread).not.toHaveBeenCalled();
+    expect(screen.getByLabelText('消息')).toHaveValue('保留这些文字');
+  });
+
+  it('only parses when explicitly requested and reuses the parsed object after a confirmation failure', async () => {
+    const base = api.call.getMockImplementation()!;
+    let confirms = 0;
+    api.call.mockImplementation(async (operation, input) => {
+      if (operation === 'confirmAttachment' && ++confirms === 1) throw new Error('确认响应丢失');
+      return base(operation, input);
+    });
+    const view = open();
+    fireEvent.click(screen.getByRole('button', { name: '对话文件' }));
+    fireEvent.click(screen.getByRole('button', { name: '添加并选择读取方式' }));
+    const choice = await screen.findByRole('combobox', { name: '附件读取方式' });
+    expect(operationCalls('confirmAttachment')).toHaveLength(0);
+    expect(operationCalls('parseAttachment')).toHaveLength(0);
+    fireEvent.change(choice, { target: { value: 'rapid_ocr' } });
+    fireEvent.click(screen.getByRole('button', { name: '添加到消息' }));
+    await screen.findByText('确认响应丢失');
+    expect(screen.getByRole('combobox', { name: '附件读取方式' })).toBeDisabled();
+    fireEvent.click(screen.getByRole('button', { name: '重试添加' }));
+    await screen.findByRole('button', { name: '移除附件 ' + photo.file_name });
+    expect(operationCalls('parseAttachment')).toEqual([['parseAttachment', { object_name: upload.object_name, parse_method: 'rapid_ocr' }]]);
+    const confirmsMade = operationCalls('confirmAttachment');
+    expect(confirmsMade).toHaveLength(2);
+    expect(confirmsMade[1]).toEqual(confirmsMade[0]);
+    expect(confirmsMade[0][1]).toEqual({ thread_id: 'thread-created', attachments: [{ object_name: upload.object_name, file_type: 'image/png', parsed_object_name: 'temporary/parsed-object' }] });
+    expect(view.ensureThread).toHaveBeenCalledTimes(1);
+    expect(api.upload).toHaveBeenCalledTimes(1);
+  });
+
+  it('browses generated files and uses the existing native save path', async () => {
+    api.call.mockImplementation(async (operation: string, input: { path?: string }) => {
+      if (operation === 'attachments') return { attachments: [] };
+      if (input.path === '/') return { files: [{ name: '作品', path: '/作品', directory_path: '/作品', is_dir: true, size: 0 }] };
+      return { files: [{ name: '故事.txt', path: '/作品/故事.txt', directory_path: '/作品', is_dir: false, size: 500 }] };
+    });
+    const view = open({ threadId: 'thread-existing' });
+    fireEvent.click(screen.getByRole('button', { name: '对话文件' }));
+    fireEvent.click(await screen.findByRole('button', { name: '作品' }));
+    fireEvent.click(await screen.findByRole('button', { name: '保存 故事.txt' }));
+    await waitFor(() => expect(api.download).toHaveBeenCalledWith('thread-existing', '/作品/故事.txt'));
+    expect(screen.getByRole('button', { name: '上一级' })).toHaveAttribute('type', 'button');
+    expect(view.ensureThread).not.toHaveBeenCalled();
+    expect(view.submit).not.toHaveBeenCalled();
+  });
+});