diff --git a/.project-docs/30-worklog/tasks/20261013-knowledge-workspace-5ac9e2d.md b/.project-docs/30-worklog/tasks/20261013-knowledge-workspace-5ac9e2d.md
new file mode 100644
index 00000000..e598e29b
--- /dev/null
+++ b/.project-docs/30-worklog/tasks/20261013-knowledge-workspace-5ac9e2d.md
@@ -0,0 +1,74 @@
+# Task: Implement split knowledge workspace and multi-file chat import then update trial
+
+## Identity
+
+- Task ID: 20261013-knowledge-workspace-5ac9e2d
+- Mode: Feature
+- Branch: codex/20261013-knowledge-workspace-5ac9e2d-knowledge-workspace
+- Worktree: /Users/chillishark/Makelore 麦洛/.codex-worktrees/makelore/20261013-knowledge-workspace-5ac9e2d
+- Base commit: 23ddce11da5c4c7aa31af81213a5aafd474cdad0
+- Owner: codex
+- Status: Ready for Integration
+
+## Scope
+
+- Implement the user-approved knowledge workspace: own-file management on the left, multi-select MakeLore/my knowledge on the right, and a clearer multi-file conversation attachment picker. Verify source changes only; the latest user correction explicitly postpones any trial update.
+
+## Intent And Constraints
+
+- Current user authorization covers implementation; the latest correction explicitly says not to update the temporary application after changes. Keep current Main/login/profile, prior accepted Agent/chat UI, resource ownership, operation recovery, saved/apply semantics, primary dirty teacher record and remote main. No desktop focus changes, no backend schema/protocol change or generated-file import. Do not prepare or activate a new trial payload, refresh/restart the application, or change its pointer. Existing Main/process/payloads must remain intact.
+
+## Outcome
+
+- Implemented stable left own-file management and right grouped multi-select knowledge panels. Small windows stack in the same order; existing draft/save/apply, ownership and selected-library semantics are preserved.
+- Replaced the two import dropdowns with a dialog: searchable dated chats with agent names, searchable file metadata, cross-chat selection, explicit target, per-file results and original-operation retry. Confirmed receipts are not replayed; actual ownership loss preserves pending intent while hiding the portal.
+- Added read-only catalog refresh and explicit two-step local retry abandonment, retaining server files; in-flight requests cannot be abandoned. Unsupported legacy formats and oversized attachments cannot be selected.
+- README reflects current branch behavior. Product source, tests and task record are isolated on this managed feature branch. No Main/shared/backend/API contract changes.
+- The latest user correction overrides the initial trial-update request: no temporary application refresh, restart, new deployment payload or pointer change was performed. Retain this checkout for later review/integration/update instructions.
+
+## Verification
+
+- Pinned corepack pnpm 10.33.4; focused existing knowledge/catalog/configuration tests: 52/52 passed. New import and adapted status tests: 27/27 passed. No real cloud mutation, native picker or model request was performed.
+- Final Renderer typecheck, scoped ESLint, production build:vite and git diff --check passed. Required project docs and own-task drift checks passed.
+- Final headless UI fixture: 9/9 passed in 26.6s with exit 0 using the repository-pinned Playwright 1.59 Chromium 1217 Headless Shell; no system browser channel. Covered multi-select/save/reopen, shared read-only access, own uploads, cross-chat selection, original-ID failure retry, reachable footer and explicit abandonment without deletion/replay at 1440px and 375px. The static Vite fixture, HTTP server, temporary directory, esbuild service and test browser all shut down normally; no owned test processes or temporary fixture directories remain. System Chrome had previously passed all assertions but hung on Browser.close because its stdout/stderr pipes stayed open after exit; the pinned test browser completed the same suite normally.
+- Inspected generated 1440px and 375px screenshots. Desktop dialog width and layered panels, small-window stacking, scrollable content and reachable footer verified. Preview evidence is under /Users/chillishark/Makelore 麦洛/.codex-evidence/knowledge-workspace-20261013-5ac9e2d.
+- Independent read-only review passed for pending intent, authorized in-flight completion, stale scope isolation, confirmed import receipts and two-step local abandonment.
+- Final read-only runtime baseline checks passed: PID 7459, Main/Renderer bytes, resources, dependencies, bootstrap, rollback copies, source trees and current renderer be53e44dcf444c9b62c3107b04f079e8ffeac450 are unchanged; runtime pointer SHA256 stays 0a01f8af424b0547c00219564d3f0bb56d0f31eaee40453c52c46ab1601bbacf. Primary stays 10da39341ead9e3db17ea4395d66181f6fe4433d; teacher record SHA256 remains 734f4de9ee0c6308b10ffa614c7678a2814f81d3b1e6d46135f495dbadeac9d3. Remote main advanced externally to bf39f4071fa957704521542e1909d53b0452c5a2: the prior full release verifier now rejects its old remote-equality condition after all runtime checks pass. No remote or primary code was changed by this task; later integration must reconcile the new remote head.
+
+## Follow-ups
+
+- The user explicitly deferred temporary application update. Await a later instruction before integration/deployment; retain the feature checkout and preview evidence.
+- Test fixtures establish UI behavior; this task does not include a live cloud import/indexing smoke test.
+
+## Promotion Candidates
+
+- None recorded.
+
+## Project Context Loaded
+
+Task context:
+- Identity above matches successful bundled start, feature ownership and task reservation.
+- 26 other owners: peer Scope/Intent/Promotion records reread read-only. Teacher consensus occupies primary main; preserve it. Older child-language task has undefined scope but no dependency here. No concrete semantic conflict; current human instruction authorizes this personal knowledge interaction change.
+
+Read:
+- AGENTS.md, new own record, read-before-planning/planning-gate and same-base context retained from the immediately preceding knowledge import review.
+- Unchanged positioning, integrated state, decisions, personal cloud Agents ADR, system/module/data flow, domain/success criteria, evidence/reflection/commitment context, README and review findings at 23ddce11. Canonical memory remains read-only.
+- Design skill and design-system/React guidance; use existing Makelore cream/blue/lavender and typography rather than generic search palette recommendations.
+- Latest runtime durable verifier and pointer: Main7459/Host62864, committed renderer be53e44, full prior rollback/snapshot preserved.
+
+Relevant understanding:
+- Goal: own documents can be indexed and explicitly selected alongside readable shared knowledge for personal Agents.
+- Scope: left upload/manage, right grouped multi-select, source/file/target-aware picker, batch independent file operation IDs and error recovery.
+- Decisions: selected knowledge alters draft only until explicit save/apply; upload/import stores documents immediately and actual indexing/chunks determine readiness; no payer-derived access.
+- Modules: CloudKnowledgeSelector, CloudKnowledge, CloudKnowledgeDocuments/new import component, scoped Agent CSS and focused unit/headless UI tests. Main services/DTO remain unchanged.
+- Unknowns: current runtime pointer/hash/process will be checked unchanged at completion; no real cloud write/model smoke is required for this UI update. Backend generated delivery import remains outside this task.
+
+Gate result:
+- Passed before implementation plan.
+
+## Plan
+
+1. Split knowledge into stable left upload/manage and right selection panels; keep loading/permission/pending safeguards and responsive stack.
+2. Replace chat import dropdowns with searchable chat/file picker, supported-document selection, independent per-file results and same-operation retry.
+3. Run focused behavior tests, Renderer type checks, scoped lint, production build and headless size/interaction verification.
+4. Commit documented result locally; verify current runtime pointer/files/process unchanged. Trial update is deferred pending a later user instruction.
diff --git a/README.md b/README.md
index 9447b4ef..2c3b8814 100644
--- a/README.md
+++ b/README.md
@@ -14,7 +14,7 @@ Makelore 是一个面向软件、视觉创作、智能机器人与个人云智
   会话工作台采用浅蓝项目栏、彩色通用手柄图标与卡片选中态；中间对话/作品使用圆角标签，作品预览的后退、前进、刷新与网址输入统一放在标签右侧；只在作品页显示，窄窗口自动换行。右侧智能体咨询使用奶油色标题区。沿用真实项目和会话入口、侧栏伸缩与账户菜单，样式只作用于 Code 会话工作台。可编辑的空对话在输入区上方的可用区域中央显示童趣欢迎语；「去作品广场逛逛」入口紧贴输入框上方，两者一起位于底部。老师介绍以固定宽度浮在右上角，不占用中间布局；欢迎语和底部输入区始终相对项目栏右侧的整个内容区域居中；小窗口的欢迎内容独立滚动；发送首条消息后收起欢迎区。侧栏保留「作品广场」入口，只有点击后才在系统浏览器打开公共广场，不请求、摘取或内嵌展示广场作品。打开广场保留当前项目、对话、草稿和附件，不自动发送消息；老师求助按钮保留临时应用的最新文案「帮我整体看🧠」。
 - `Makelore Agents｜AI 智能体`：从模块首页进入时先打开“我的智能体”卡片列表，保留此前对话与操作恢复记录；返回首页箭头与侧栏折叠按钮同排，折叠后仍可返回；智能体模块的侧栏只通过按钮点击或键盘激活展开，鼠标经过左侧、收纳按钮或顶栏不会展开，切换模块不沿用旧悬停预览；其他模块仍保留原预览方式。“我的智能体”使用浅紫对话机器人图标，“渠道”使用浅蓝连接节点图标。macOS 原生窗口按钮留出安全空间。首页围绕自己的智能体和创建入口，显示童趣问候“Hi，今天想创造还是想聊聊？”，不再显示更多、收到的分享、活动或归档筛选。卡片恢复原有尺寸与留白，显示名称、可为空的一句话介绍及状态，支持聊天、调整、继续制作和确认删除；删除沿用云端归档机制，移出列表并停用新调用，历史和费用保留。创建先填写名称并选择平台像素头像或上传头像，下一步进入独立配置。顶部名称有编辑图标，头像可点击修改；未设置头像时使用同一张默认像素头像，从创建到配置、改名、保存和重新打开保持一致。基础页为“介绍与提示词”，一句话介绍可留空，完整提示词保留原始文本；模型作为高级设置第一项必选，未选择时不能开始使用，草稿可分步保存，不自动选模型。介绍与提示词采用浅蓝介绍卡和浅紫提示词卡；高级设置按模型、工具箱（Tool）、做事手册（Skill）、MCP 服务、子智能体和知识库纵向呈现，不再设内部分类切换；不展示 Tool/Skill 解释、资源开放规则提示、云端能力管理、费用上限或运行限制卡片，保存其他配置时保留既有运行限制，费用规则不变。顶层页签切换保留搜索、资源选择、知识表单及未保存输入。配置页移除聊天、自动任务和使用与接入导航，独立聊天仍从卡片进入，微信账号仍在侧栏渠道管理。草稿明确保存（Ctrl/⌘+S）；保存只更新草稿，“应用最新修改”使新配置生效，失败重试保持原操作身份；点击“开始使用”完成必要的私有启用后直接打开聊天，不再展示二次确认页；未保存修改、缺少模型、冲突或尚未确认的请求会留在配置页处理，打开聊天不自动发送消息。独立对话沿用奶油底色和浅蓝、浅紫、薄荷色：顶部展示返回、只读头像和名称；有附件时在同一行右侧显示回形针“附件”入口和文件数量，不展示调整、保存／应用状态、客户端／微信来源、费用／版本说明或历史／新对话图标；配置由列表卡片的“调整”进入。空对话展示当前智能体头像与名称，示例只填入草稿；用户消息使用浅紫圆角气泡，助手 Markdown、表格和代码在消息区内滚动。文件或图片从输入框内添加，上传成功后以待发送卡片呈现，可移除本次携带；移除不会删除云端文件，添加不会自动发送。确认失败沿用同一文件和对话重试，发送前需完成或取消添加；支持仅发送附件，使用明确的附件提问。输入框的“＋”添加文件或图片；右上角“附件”打开右侧面板，按“你上传的”和“助手生成的”分组，支持再次选用已上传附件及保存明确交付的生成文件。生成文件仅取当前对话已保存助手回复中的本地文件链接（含图片与引用式链接），核对实际文件后展示和计数；只读取链接所在的文件夹，不遍历全部工作文件。未交付的脚本、缓存和工具记录不展示、不计数，明确交付的代码照常展示；仅写了路径的旧成果可能暂时隐藏，后续接入 Yuxi 的正式交付记录。没有文件时隐藏入口；打开、关闭面板保留聊天与输入，Escape 关闭并返回入口焦点；最近对话自动恢复、审批、停止和未发送内容的离开保护保留。模型返回的思考独立于正文展示，运行时可展开、手动折叠，完成后折叠；无思考内容时不显示。重连事件去重并隔离当前运行与主对话，终态历史未到达时保留已收到的片段并有限补读；服务端返回的最终回答思考可在历史中回看，不进入后续提问。历史回看需要 Yuxi API 思考投影补丁上线，当前未部署；实时思考沿用既有事件流。头像上传、Main-owned Host API、访问隔离、费用与不可变版本规则保持；介绍留空需要配套 Yuxi DraftCreate/DraftSave 的空字符串契约。
 
-  高级配置的知识库支持下拉多选，分为「MakeLore知识」和「我的知识库」，已选项可单独移除。MakeLore知识来自当前账号有权读取的 Yuxi 共享目录，只显示名称与简介；移除仅取消当前智能体选用，不删除原库。我的知识库以服务端本人管理目录为准，提供「上传自己的文件」入口，可新建库或追加到已有个人库，上传后自动解析、建立索引并持续显示真实处理状态；失败可重试且保留已有可用内容。暂不可选用的个人库仍可管理文件，已有绑定保留并提示不可用；未确认请求在当前库保留同一操作身份供重试。知识库选择只改草稿，显式保存／应用后生效；个人云端执行已自动接入所选知识库的检索，无需另外勾选 knowledge-base Skill。此交互复用现有接口，无需新增后端补丁。
+  高级配置的知识库支持下拉多选，分为「MakeLore知识」和「我的知识库」，已选项可单独移除。MakeLore知识来自当前账号有权读取的 Yuxi 共享目录，只显示名称与简介；移除仅取消当前智能体选用，不删除原库。知识库区域左右分区：左侧「上传自己的文件」管理本人知识库，右侧选择「MakeLore知识」和「我的知识库」，小窗口上下排列。左侧可新建库或追加资料，提供「从电脑上传」和「从聊天选择文件」；聊天文件选择面板显示目标知识库、可搜索的来源聊天和文件名称／类型／大小，支持多选，逐文件导入并保留独立操作身份，部分失败只重试失败项；也可明确确认放弃本页重试，已保存文件仍保留。仅选本人已上传的聊天附件，聊天正文和助手生成的文件不直接入库。上传和导入后自动解析、建立索引并持续显示真实处理状态；失败可重试且保留已有可用内容。使用说明与费用以折叠说明呈现。暂不可选用的个人库仍可管理文件，已有绑定保留并提示不可用；未确认请求在当前库保留同一操作身份供重试。知识库选择只改草稿，显式保存／应用后生效；个人云端执行已自动接入所选知识库的检索，无需另外勾选 knowledge-base Skill。此交互复用现有接口，无需新增后端补丁。
 
   云知识库的 embedding 模型只由平台管理员在 Yuxi 后台维护：在「智能体管理 → 模型供应商」启用供应商，按供应商要求填写有效的服务地址和 API Key，添加并启用 embedding 模型并填写实际向量维度；embedding 向量化费用由平台承担，不计入用户用量、词元点数或智能体费用上限；one-api 不参与 embedding 配置，Works Square 只负责其他应计费模型调用的创建者词元点数账本。客户端区分目录加载中、加载失败与无可用模型，空状态提供管理员配置说明；「刷新知识库与模型」保留未提交名称，未确认的创建请求沿用原操作身份。
 
diff --git a/src/pages/CloudAgents/CloudKnowledge.tsx b/src/pages/CloudAgents/CloudKnowledge.tsx
index 2e95e870..a54ee14b 100644
--- a/src/pages/CloudAgents/CloudKnowledge.tsx
+++ b/src/pages/CloudAgents/CloudKnowledge.tsx
@@ -1,4 +1,5 @@
-import { useEffect, useRef, useState } from 'react';
+import { useEffect, useId, useRef, useState } from 'react';
+import { Upload } from 'lucide-react';
 import { cloudAgentsApi } from '@/lib/cloud-agents-api';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
@@ -27,6 +28,7 @@ export function CloudKnowledgePanel({ slug, onCreated, onDeleted, onSelected, on
   const [refresh, setRefresh] = useState(0);
   const [creating, setCreating] = useState(false);
   const [documentPending, setDocumentPending] = useState(false);
+  const targetId = useId();
   const createIntent = useRef<{ operation_id: string; name: string; embedding_model: string } | null>(null);
   usePendingCloudInput(busy || documentPending || Boolean(createIntent.current) || (creating && Boolean(name.trim())));
   const operationInFlight = useRef(false);
@@ -62,15 +64,15 @@ export function CloudKnowledgePanel({ slug, onCreated, onDeleted, onSelected, on
   const selectedKnowledge = manageable.find(kb => kb.kb_id === kbId);
   const managementDisabled = disabled || busy || catalogLoading || Boolean(catalogError);
   const bindable = (id: string) => selectableIds === undefined || Boolean(selectableIds?.includes(id));
-  return <details className="rounded-lg border p-4">
-    <summary className="min-h-8 cursor-pointer text-sm font-medium">上传自己的文件</summary>
-    <div className="mt-4 space-y-4 text-sm">
-      <p className="text-xs leading-5 text-muted-foreground">选择或新建自己的知识库，再上传文件。选用只会加入当前配置，保存并应用后生效。</p>
-      <p className="text-xs leading-5 text-muted-foreground">上传到知识库的文档可供获准使用此智能体的人检索。解析并建立索引后才会生效；embedding 向量化由平台承担，不计入用户用量、词元点数或智能体费用上限。知识处理如触发对话模型调用，仍按原模型实际用量计费。</p>
+  return <section aria-label="上传自己的文件" className="agent-knowledge-upload space-y-4">
+    <div className="agent-knowledge-panel-heading"><Upload aria-hidden="true" className="size-5" /><h3>上传自己的文件</h3></div>
+    <div className="space-y-4 text-sm">
+      <p className="text-xs leading-5 text-muted-foreground">选择或新建自己的知识库，再从电脑或聊天中添加资料。选用会加入右侧配置，保存并应用后生效。</p>
+      <label htmlFor={targetId} className="agent-knowledge-field-label">添加到我的知识库</label>
       {error && <p role="alert" className="text-destructive">{error}</p>}
       {catalogError && <p role="alert" className="text-destructive">知识库与模型目录加载失败：{catalogError}。请刷新重试。</p>}
       <div className="flex flex-wrap gap-2">
-        <select aria-label="管理的知识库" className="h-10 min-w-0 flex-1 basis-48 rounded-md border bg-background px-3" value={kbId} disabled={managementDisabled || documentPending}
+        <select id={targetId} aria-label="管理的知识库" className="h-10 min-w-0 flex-1 basis-48 rounded-md border bg-background px-3" value={kbId} disabled={managementDisabled || documentPending}
           onChange={e => {
             const selected = manageable.find(kb => kb.kb_id === e.target.value);
             if (managementDisabled || documentPending || (selected && bindable(selected.kb_id) && selectionFull && !selectedIds.includes(selected.kb_id))) return;
@@ -86,6 +88,10 @@ export function CloudKnowledgePanel({ slug, onCreated, onDeleted, onSelected, on
         <Button type="button" variant="outline" disabled={disabled || busy || documentPending || selectionFull || Boolean(createIntent.current)} onClick={() => setCreating(v => !v)}>新建知识库</Button>
         <Button type="button" variant="ghost" disabled={disabled || busy || catalogLoading} onClick={() => setRefresh(v => v + 1)}>刷新知识库与模型</Button>
       </div>
+      <details className="agent-knowledge-help">
+        <summary>使用说明与费用</summary>
+        <p className="mt-2 text-xs leading-5 text-muted-foreground">上传到知识库的文档可供获准使用此智能体的人检索。解析并建立索引后才会生效；embedding 向量化由平台承担，不计入用户用量、词元点数或智能体费用上限。知识处理如触发对话模型调用，仍按原模型实际用量计费。</p>
+      </details>
       {!catalogLoading && !catalogError && !manageable.length && <p className="text-xs leading-5 text-muted-foreground">还没有可管理的知识库，可以新建一个保存自己的文件。MakeLore知识仅供检索。</p>}
       {selectedKnowledge && selectableIds !== undefined && !bindable(selectedKnowledge.kb_id) && <p role="status" className="text-xs leading-5 text-amber-800">
         {selectableIds === null ? '知识库选用状态待确认。' : '这个知识库当前暂不可选用。'}你仍可管理自己的文件，刷新目录后再试。
@@ -126,9 +132,9 @@ export function CloudKnowledgePanel({ slug, onCreated, onDeleted, onSelected, on
         </Button>
         {documentPending && <p className="text-xs leading-5 text-muted-foreground">放弃只清除本地重试请求，不会删除已保存的文件。重新进入后可确认服务器状态。</p>}
       </div>}
-      {kbId && <div hidden={!selectedKnowledge}><CloudKnowledgeDocuments key={slug + ':' + kbId} slug={slug} kbId={kbId} busy={managementDisabled || !selectedKnowledge}
-        canRead={Boolean(selectedKnowledge)} act={act} onPendingChange={setDocumentPending}
+      {kbId && <div hidden={!selectedKnowledge}><CloudKnowledgeDocuments key={slug + ':' + kbId} slug={slug} kbId={kbId} kbName={selectedKnowledge?.name} busy={managementDisabled || !selectedKnowledge}
+        canRead={Boolean(selectedKnowledge)} act={act} onPendingChange={setDocumentPending} onRefreshKnowledge={() => setRefresh(v => v + 1)}
         onDeleteKnowledge={() => { callbacks.current.onDeleted?.(kbId); setKbId(''); setDocumentPending(false); setRefresh(v => v + 1); }} /></div>}
     </div>
-  </details>;
+  </section>;
 }
diff --git a/src/pages/CloudAgents/CloudKnowledgeAttachmentPicker.tsx b/src/pages/CloudAgents/CloudKnowledgeAttachmentPicker.tsx
new file mode 100644
index 00000000..88c0509c
--- /dev/null
+++ b/src/pages/CloudAgents/CloudKnowledgeAttachmentPicker.tsx
@@ -0,0 +1,280 @@
+import { useEffect, useRef, useState } from 'react';
+import { CheckCircle2, FileText, Loader2, Search, X } from 'lucide-react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Dialog, DialogContent, DialogDescription, DialogTitle } from '@/components/ui/dialog';
+import { cloudAgentsApi } from '@/lib/cloud-agents-api';
+import { usePendingCloudInput } from './CloudPending';
+import type { CloudAttachment, CloudKnowledgeFile, CloudThread } from '../../../shared/cloud-agents';
+
+type Selection = { key: string; threadId: string; threadTitle: string; file: CloudAttachment };
+type ImportJob = Selection & {
+  operationId: string; status: 'queued' | 'running' | 'saved' | 'failed' | 'done';
+  importedFile?: CloudKnowledgeFile; error?: string;
+};
+
+function fileDetails(file: CloudAttachment) {
+  const extension = file.file_name.split('.').pop()?.toLowerCase() ?? '';
+  const type = file.file_name.includes('.') ? extension.toUpperCase() : '文件';
+  const size = Number.isFinite(file.file_size)
+    ? file.file_size < 1024 ? `${file.file_size} B` : file.file_size < 1024 * 1024
+      ? `${Math.ceil(file.file_size / 1024)} KB` : `${(file.file_size / (1024 * 1024)).toFixed(1)} MB`
+    : '大小未知';
+  const reason = file.file_size > 5 * 1024 * 1024 ? '超过 5 MB，暂不能导入'
+    : !/^(txt|md|csv|json|docx|xlsx|pdf)$/.test(extension) ? '此格式暂不支持知识库导入' : '';
+  return { type, size, reason };
+}
+
+function updatedDate(value: string) {
+  const date = new Date(value);
+  return Number.isFinite(date.getTime()) ? date.toLocaleDateString('zh-CN', { month: 'numeric', day: 'numeric', year: 'numeric' }) : '更新时间未知';
+}
+function errorMessage(error: unknown) { return error instanceof Error ? error.message : '请稍后重试。'; }
+
+export function CloudKnowledgeAttachmentPicker({ slug, kbId, kbName, busy, canRead = true, act, onImported, onPendingChange, onClose, onRefreshKnowledge }: {
+  slug: string; kbId: string; kbName: string; busy: boolean; canRead?: boolean;
+  act: (operation: () => Promise<void>) => Promise<void>;
+  onImported: (file: CloudKnowledgeFile) => Promise<void>;
+  onPendingChange: (pending: boolean) => void;
+  onClose?: () => void; onRefreshKnowledge?: () => void;
+}) {
+  const scope = slug + ':' + kbId;
+  const [threads, setThreads] = useState<CloudThread[]>([]);
+  const [agentNames, setAgentNames] = useState<Record<string, string>>({});
+  const [threadId, setThreadId] = useState('');
+  const [threadQuery, setThreadQuery] = useState('');
+  const [fileQuery, setFileQuery] = useState('');
+  const [files, setFiles] = useState<{ threadId: string; items: CloudAttachment[] }>({ threadId: '', items: [] });
+  const [threadsLoading, setThreadsLoading] = useState(true);
+  const [filesLoading, setFilesLoading] = useState(false);
+  const [threadError, setThreadError] = useState('');
+  const [fileError, setFileError] = useState('');
+  const [threadsRevision, setThreadsRevision] = useState(0);
+  const [filesRevision, setFilesRevision] = useState(0);
+  const [selected, setSelected] = useState<Selection[]>([]);
+  const [jobs, setJobs] = useState<ImportJob[]>([]);
+  const [running, setRunning] = useState(false);
+  const [completed, setCompleted] = useState(0);
+  const [abandoning, setAbandoning] = useState(false);
+  const jobsRef = useRef<ImportJob[]>([]);
+  const runningRef = useRef(false);
+  const alive = useRef(true);
+  const activeScope = useRef(scope);
+  const permitted = useRef(canRead);
+  const callbacks = useRef({ onImported, onClose });
+  useEffect(() => { callbacks.current = { onImported, onClose }; }, [onImported, onClose]);
+  useEffect(() => { permitted.current = canRead; }, [canRead]);
+  useEffect(() => { alive.current = true; return () => { alive.current = false; }; }, []);
+  useEffect(() => {
+    activeScope.current = scope;
+    jobsRef.current = []; runningRef.current = false;
+    setJobs([]); setSelected([]); setThreadId(''); setThreadQuery(''); setFileQuery(''); setCompleted(0); setRunning(false); setAbandoning(false);
+  }, [scope]);
+  const unresolved = jobs.some(job => job.status !== 'done');
+  const pending = running || unresolved || selected.length > 0;
+  const locked = busy || !canRead || running || unresolved;
+  usePendingCloudInput(pending);
+  useEffect(() => { onPendingChange(pending); return () => onPendingChange(false); }, [pending, onPendingChange]);
+
+  useEffect(() => {
+    let live = true;
+    setThreads([]); setThreadError(''); setThreadsLoading(canRead);
+    if (!canRead) return;
+    const load = async () => {
+      try {
+        let page = await cloudAgentsApi.call('threads', {});
+        const all = [...page.threads];
+        const seen = new Set<number>();
+        while (live && page.next_offset !== null) {
+          if (seen.has(page.next_offset)) throw new Error('对话列表读取未完成，请重试。');
+          seen.add(page.next_offset);
+          page = await cloudAgentsApi.call('threads', { offset: page.next_offset });
+          all.push(...page.threads);
+        }
+        if (live) setThreads([...new Map(all.map(thread => [thread.thread_id, thread])).values()]);
+      } catch (error) { if (live) setThreadError(errorMessage(error)); }
+      finally { if (live) setThreadsLoading(false); }
+    };
+    void load();
+    return () => { live = false; };
+  }, [scope, canRead, threadsRevision]);
+
+  useEffect(() => {
+    let live = true;
+    setAgentNames({});
+    if (!canRead) return;
+    const names: Record<string, string> = {};
+    const publish = () => { if (live) setAgentNames({ ...names }); };
+    // Names are supplementary: an unavailable agent directory must not hide chat files.
+    const ownNames = async () => {
+      let page = await cloudAgentsApi.list();
+      const seen = new Set<string>();
+      for (;;) {
+        for (const agent of page.agents) names[agent.slug] = agent.name;
+        publish();
+        if (!live || !page.next_cursor || seen.has(page.next_cursor)) return;
+        seen.add(page.next_cursor);
+        page = await cloudAgentsApi.list(page.next_cursor);
+      }
+    };
+    void ownNames().catch(() => undefined);
+    void cloudAgentsApi.call('received', {}).then(page => {
+      if (!live) return;
+      for (const agent of page.agents) names[agent.slug] = agent.name;
+      publish();
+    }).catch(() => undefined);
+    return () => { live = false; };
+  }, [scope, canRead, threadsRevision]);
+
+  useEffect(() => {
+    let live = true;
+    setFiles({ threadId, items: [] }); setFileError(''); setFilesLoading(Boolean(threadId) && canRead);
+    if (!threadId || !canRead) return;
+    cloudAgentsApi.call('attachments', { thread_id: threadId }).then(page => {
+      if (live) setFiles({ threadId, items: page.attachments });
+    }).catch(error => { if (live) setFileError(errorMessage(error)); })
+      .finally(() => { if (live) setFilesLoading(false); });
+    return () => { live = false; };
+  }, [scope, canRead, threadId, filesRevision]);
+
+  const currentThread = threads.find(thread => thread.thread_id === threadId);
+  const visibleThreads = threads.filter(thread => `${thread.title} ${agentNames[thread.agent_slug] ?? ''}`.toLocaleLowerCase().includes(threadQuery.trim().toLocaleLowerCase()));
+  const visibleFiles = files.threadId === threadId ? files.items.filter(file => file.file_name.toLocaleLowerCase().includes(fileQuery.trim().toLocaleLowerCase())) : [];
+  const retryJobs = jobs.filter(job => job.status !== 'done');
+  const failureOnly = retryJobs.length > 0 && retryJobs.every(job => job.status === 'failed');
+  const selectedKeys = new Set(selected.map(item => item.key));
+
+  function choose(file: CloudAttachment, checked: boolean) {
+    if (locked || !currentThread || filesLoading || fileError || fileDetails(file).reason) return;
+    const key = JSON.stringify([threadId, file.file_id]);
+    if (jobsRef.current.length && jobsRef.current.every(job => job.status === 'done')) { jobsRef.current = []; setJobs([]); }
+    setCompleted(0);
+    setSelected(previous => checked ? [...previous.filter(item => item.key !== key), {
+      key, threadId, threadTitle: currentThread.title || '未命名对话', file,
+    }] : previous.filter(item => item.key !== key));
+  }
+
+  async function importSelected() {
+    if (busy || !canRead || runningRef.current) return;
+    const attemptScope = scope;
+    const current = () => alive.current && activeScope.current === attemptScope;
+    const initialJobs: ImportJob[] = jobsRef.current.length ? jobsRef.current : selected.map(item => ({
+      ...item, operationId: crypto.randomUUID(), status: 'queued' as const,
+    }));
+    const attempts = initialJobs.filter(job => job.status !== 'done');
+    if (!attempts.length) return;
+    const update = (key: string, value: Partial<ImportJob>) => {
+      jobsRef.current = jobsRef.current.map(job => job.key === key ? { ...job, ...value } : job);
+      setJobs([...jobsRef.current]);
+    };
+    jobsRef.current = initialJobs; setJobs([...initialJobs]);
+    runningRef.current = true; setRunning(true); setAbandoning(false);
+    try {
+      await act(async () => {
+        for (const job of attempts) {
+          if (!current() || !permitted.current) return;
+          update(job.key, { status: 'running', error: '' });
+          try {
+            const file = job.importedFile ?? await cloudAgentsApi.call('importKnowledgeAttachment', {
+              slug, kb_id: kbId, thread_id: job.threadId, attachment_id: job.file.file_id, operation_id: job.operationId,
+            });
+            if (!current()) return;
+            // A confirmed import is never repeated, even if permission changes or processing fails.
+            update(job.key, { status: 'saved', importedFile: file });
+            if (!permitted.current) return;
+            try {
+              await callbacks.current.onImported(file);
+              if (!current()) return;
+              update(job.key, { status: 'done', error: '' });
+            } catch (error) {
+              if (!current()) return;
+              update(job.key, { status: 'done', error: '文件已导入，处理未全部启动。请在知识库重试处理。' + errorMessage(error) });
+            }
+          } catch (error) {
+            if (!current()) return;
+            update(job.key, { status: 'failed', error: '导入结果尚未确认：' + errorMessage(error) });
+          }
+        }
+        if (current() && jobsRef.current.every(job => job.status === 'done')) {
+          setSelected([]); setCompleted(jobsRef.current.length);
+          if (jobsRef.current.every(job => !job.error)) {
+            jobsRef.current = []; setJobs([]);
+            callbacks.current.onClose?.();
+          }
+        }
+      });
+    } finally {
+      if (current()) { runningRef.current = false; setRunning(false); }
+    }
+  }
+
+  const close = () => { if (!runningRef.current && !unresolved) onClose?.(); };
+  return <Dialog open={canRead} onOpenChange={open => { if (!open) close(); }}>
+    <DialogContent className="agent-knowledge-import agent-knowledge-import-modal"
+      onEscapeKeyDown={event => { if (runningRef.current || unresolved) event.preventDefault(); }}
+      onInteractOutside={event => { if (runningRef.current || unresolved) event.preventDefault(); }}>
+    <div className="agent-knowledge-import-header">
+      <div><DialogTitle>从聊天选择文件</DialogTitle><DialogDescription>导入到「{kbName}」</DialogDescription></div>
+      {onClose && <Button type="button" variant="ghost" size="icon" aria-label="关闭文件选择" disabled={running || unresolved}
+        onClick={close}><X size={18} /></Button>}
+    </div>
+    <div className="agent-knowledge-import-content">
+    <p className="agent-knowledge-import-help">选择你在 MakeLore Agents 聊天中上传的文件。聊天文字和助手生成的文件不会导入。</p>
+    {!canRead && <p role="status">知识库管理权限待确认，文件操作已暂停；未完成请求仍保留。</p>}
+    {canRead && <div className="agent-knowledge-import-body">
+      <section className="agent-knowledge-import-chats" aria-label="来源对话">
+        <h3>选择对话</h3>
+        <div className="agent-knowledge-import-search"><Search size={16} aria-hidden="true" /><Input aria-label="搜索对话" placeholder="搜索对话或智能体" value={threadQuery} disabled={locked} onChange={event => setThreadQuery(event.target.value)} /></div>
+        <div className="agent-knowledge-import-chat-list">
+          {threadsLoading ? <p role="status">正在读取对话…</p> : threadError ? <div><p role="alert">对话读取失败：{threadError}</p><Button type="button" variant="ghost" disabled={locked} onClick={() => setThreadsRevision(value => value + 1)}>重试读取对话</Button></div>
+            : !threads.length ? <p>还没有个人智能体对话。</p> : !visibleThreads.length ? <p>没有匹配的对话。</p> : visibleThreads.map(thread => <button type="button" key={thread.thread_id}
+              className="agent-knowledge-import-chat" aria-label={'选择对话 ' + (thread.title || '未命名对话')} aria-pressed={threadId === thread.thread_id} disabled={locked}
+              onClick={() => { if (!locked) { setThreadId(thread.thread_id); setFileQuery(''); } }}>
+              <strong>{thread.title || '未命名对话'}</strong><small>{agentNames[thread.agent_slug] || '智能体名称暂不可用'} · {updatedDate(thread.updated_at)}</small>
+            </button>)}
+        </div>
+      </section>
+      <section className="agent-knowledge-import-files" aria-label="聊天中上传的文件">
+        <h3>{currentThread?.title || '选择文件'}</h3>
+        <div className="agent-knowledge-import-search"><Search size={16} aria-hidden="true" /><Input aria-label="搜索文件" placeholder="搜索文件名" value={fileQuery} disabled={locked || !threadId} onChange={event => setFileQuery(event.target.value)} /></div>
+        <div className="agent-knowledge-import-file-list">
+          {!threadId ? <p>先选择一段对话，再挑选其中的文件。</p> : filesLoading ? <p role="status">正在读取文件…</p>
+            : fileError ? <div><p role="alert">文件读取失败：{fileError}</p><Button type="button" variant="ghost" disabled={locked} onClick={() => setFilesRevision(value => value + 1)}>重试读取文件</Button></div>
+              : !files.items.length ? <p>这段对话还没有上传文件。</p> : !visibleFiles.length ? <p>没有匹配的文件。</p> : visibleFiles.map(file => {
+                const details = fileDetails(file), key = JSON.stringify([threadId, file.file_id]);
+                return <label key={file.file_id} className="agent-knowledge-import-file" data-selected={selectedKeys.has(key)} data-disabled={Boolean(details.reason)}>
+                  <input type="checkbox" aria-label={'选择文件 ' + file.file_name} checked={selectedKeys.has(key)} disabled={locked || Boolean(details.reason)} onChange={event => choose(file, event.target.checked)} />
+                  <FileText size={20} aria-hidden="true" /><span><strong>{file.file_name}</strong><small>{details.type} · {details.size}</small>{details.reason && <small>{details.reason}</small>}</span>
+                </label>;
+              })}
+        </div>
+      </section>
+    </div>}
+    {selected.length > 0 && <div className="agent-knowledge-import-selection"><p>已选 {selected.length} 个文件{locked ? '。' : '，可继续切换对话选择。'}</p>
+      <ul aria-label="已选聊天文件">{selected.map(item => <li key={item.key}><span>{item.file.file_name}<small>{item.threadTitle}</small></span>
+        <Button type="button" variant="ghost" size="icon" aria-label={'移除所选文件 ' + item.file.file_name} disabled={locked} onClick={() => { if (!locked) setSelected(previous => previous.filter(file => file.key !== item.key)); }}><X size={15} /></Button></li>)}</ul>
+    </div>}
+    {jobs.length > 0 && <ul className="agent-knowledge-import-results" aria-label="文件导入结果">{jobs.map(job => <li key={job.key}>
+      <span>{job.file.file_name}</span><span>{job.status === 'done' ? <><CheckCircle2 size={15} />已导入，处理状态见知识库</> : job.status === 'running' ? '正在导入…' : job.status === 'saved' ? '已保存，等待继续处理' : job.status === 'failed' ? '等待重试' : '等待导入'}</span>
+      {job.error && <p role="alert">{job.error}</p>}
+    </li>)}</ul>}
+    {abandoning && <div className="agent-knowledge-import-abandon" role="group" aria-label="放弃当前页面的重试">
+      <p>这只会结束当前页面的重试。已保存的文件会保留，可刷新知识库确认。</p>
+      <div className="flex flex-wrap gap-2"><Button type="button" variant="outline" disabled={running} onClick={() => {
+        if (runningRef.current) return;
+        jobsRef.current = []; setJobs([]); setSelected([]); setCompleted(0); setAbandoning(false);
+        callbacks.current.onClose?.();
+      }}>确认放弃重试</Button><Button type="button" variant="ghost" disabled={running} onClick={() => setAbandoning(false)}>继续保留</Button></div>
+    </div>}
+    </div>
+    <div className="agent-knowledge-import-footer">
+      <p>最大 5 MB；支持文本、Word、Excel、文本 PDF。导入后自动处理，可用于回答后才能检索。</p>
+      {onRefreshKnowledge && <Button type="button" variant="outline" disabled={running} onClick={() => { if (!runningRef.current) onRefreshKnowledge(); }}>刷新知识库</Button>}
+      {unresolved && !running && !abandoning && <Button type="button" variant="ghost" onClick={() => setAbandoning(true)}>放弃重试</Button>}
+      <Button type="button" disabled={busy || !canRead || running || (!selected.length && !retryJobs.length)} onClick={() => void importSelected()}>
+        {running ? <><Loader2 size={16} className="animate-spin" />正在导入…</> : retryJobs.length ? `${failureOnly ? '重试失败的' : '继续导入'} ${retryJobs.length} 个文件` : `导入 ${selected.length} 个文件`}
+      </Button>
+    </div>
+    {completed > 0 && <p role="status">已导入 {completed} 个文件，处理状态见知识库。</p>}
+  </DialogContent></Dialog>;
+}
diff --git a/src/pages/CloudAgents/CloudKnowledgeDocuments.tsx b/src/pages/CloudAgents/CloudKnowledgeDocuments.tsx
index 14e0ac64..1a778f84 100644
--- a/src/pages/CloudAgents/CloudKnowledgeDocuments.tsx
+++ b/src/pages/CloudAgents/CloudKnowledgeDocuments.tsx
@@ -3,7 +3,8 @@ import { CheckCircle2, CircleAlert, FileText, Loader2 } from 'lucide-react';
 import { cloudAgentsApi } from '@/lib/cloud-agents-api';
 import { Button } from '@/components/ui/button';
 import { usePendingCloudInput } from './CloudPending';
-import type { CloudKnowledgeFile, CloudThread, CloudAttachment } from '../../../shared/cloud-agents';
+import { CloudKnowledgeAttachmentPicker } from './CloudKnowledgeAttachmentPicker';
+import type { CloudKnowledgeFile } from '../../../shared/cloud-agents';
 
 function documentState(file: CloudKnowledgeFile) {
   const task = file.processing_task;
@@ -47,11 +48,11 @@ function documentState(file: CloudKnowledgeFile) {
   return { label: '状态待确认', detail: '请刷新状态后再操作。', stage: 0 };
 }
 
-export function CloudKnowledgeDocuments({ slug, kbId, busy, act, onDeleteKnowledge, canRead = true, onPendingChange }: {
-  slug: string; kbId: string; busy: boolean;
+export function CloudKnowledgeDocuments({ slug, kbId, kbName = '当前知识库', busy, act, onDeleteKnowledge, canRead = true, onPendingChange, onRefreshKnowledge }: {
+  slug: string; kbId: string; kbName?: string; busy: boolean;
   act: (operation: () => Promise<void>) => Promise<void>;
   onDeleteKnowledge: () => void;
-  canRead?: boolean; onPendingChange?: (pending: boolean) => void;
+  canRead?: boolean; onPendingChange?: (pending: boolean) => void; onRefreshKnowledge?: () => void;
 }) {
   const [files, setFiles] = useState<CloudKnowledgeFile[]>([]);
   const [pageCount, setPageCount] = useState(1);
@@ -154,14 +155,14 @@ export function CloudKnowledgeDocuments({ slug, kbId, busy, act, onDeleteKnowled
   const active = states.some(state => state.active) || submitting !== null;
   return <div className="space-y-4">
     <div className="flex flex-wrap items-center gap-2">
-      <Button type="button" disabled={busy || !canRead || (unresolved && !uploadIntents.current.new)} onClick={() => void upload()}>{uploadIntents.current.new ? '重新选择同一文件并重试' : '上传文档'}</Button>
-      <Button type="button" variant="outline" disabled={busy || !canRead || unresolved} onClick={() => setImporting(value => !value)}>从对话附件导入</Button>
+      <Button type="button" disabled={busy || !canRead || (unresolved && !uploadIntents.current.new)} onClick={() => void upload()}>{uploadIntents.current.new ? '重新选择同一文件并重试' : '从电脑上传'}</Button>
+      <Button type="button" variant="outline" disabled={busy || !canRead || unresolved} onClick={() => setImporting(value => !value)}>从聊天选择文件</Button>
       <Button type="button" variant="ghost" disabled={loading || !canRead} onClick={refresh}>刷新状态</Button>
     </div>
     <p className="text-xs leading-5 text-muted-foreground">上传后自动解析并建立索引。最大 5 MB；支持 TXT、Markdown、CSV、JSON、Word、Excel、文本 PDF。</p>
     {uploading && <p role="status" className="flex items-center gap-2 text-sm"><Loader2 className="size-4 animate-spin" />{uploading}</p>}
-    {importing && <AttachmentImport slug={slug} kbId={kbId} busy={busy || !canRead} act={act} onPendingChange={setImportPending}
-      onImported={async file => { setImporting(false); await acceptFile(file); }} />}
+    {importing && <CloudKnowledgeAttachmentPicker slug={slug} kbId={kbId} kbName={kbName} busy={busy} canRead={canRead}
+      act={act} onPendingChange={setImportPending} onImported={acceptFile} onClose={() => setImporting(false)} onRefreshKnowledge={onRefreshKnowledge} />}
     <div className="flex flex-wrap items-center justify-between gap-2 border-b pb-2 text-xs text-muted-foreground" aria-live="polite">
       <span>{files.length ? '已显示 ' + files.length + ' 份文档 · ' + states.filter(state => state.ready).length + ' 份可用' : '知识文档'}</span>
       <span>{active ? '处理中 · 状态自动更新' : '状态自动更新'}</span>
@@ -215,52 +216,11 @@ export function CloudKnowledgeDocuments({ slug, kbId, busy, act, onDeleteKnowled
     {deleting && <div role="dialog" aria-label="删除知识内容" className="space-y-3 rounded-lg border border-amber-200 p-3">
       <p>{deleting === 'database' ? '删除整个知识库及其文档、索引？所有使用此库的智能体将无法继续检索这些内容。' : '删除文档“' + deleting.name + '”及其索引？'}</p>
       <div className="flex gap-2"><Button type="button" variant="outline" disabled={busy || unresolved} onClick={() => void act(async () => {
-        if (deleting === 'database') { await cloudAgentsApi.call('deleteKnowledge', { slug, kb_id: kbId }); onDeleteKnowledge(); }
+        if (!alive.current || !permitted.current) return;
+        if (deleting === 'database') { await cloudAgentsApi.call('deleteKnowledge', { slug, kb_id: kbId }); if (alive.current) onDeleteKnowledge(); }
         else await cloudAgentsApi.call('deleteKnowledgeFile', { slug, kb_id: kbId, file_id: deleting.file_id });
         if (alive.current) { setDeleting(null); refresh(); }
       })}>确认删除知识内容</Button><Button type="button" variant="ghost" disabled={busy} onClick={() => setDeleting(null)}>取消</Button></div>
     </div>}
   </div>;
 }
-
-function AttachmentImport({ slug, kbId, busy, act, onImported, onPendingChange }: {
-  slug: string; kbId: string; busy: boolean; act: (operation: () => Promise<void>) => Promise<void>;
-  onImported: (file: CloudKnowledgeFile) => Promise<void>;
-  onPendingChange: (pending: boolean) => void;
-}) {
-  const [threads, setThreads] = useState<CloudThread[]>([]);
-  const [thread, setThread] = useState('');
-  const [files, setFiles] = useState<CloudAttachment[]>([]);
-  const [file, setFile] = useState('');
-  const [error, setError] = useState('');
-  const operation = useRef<string | null>(null);
-  const unresolved = Boolean(operation.current);
-  useEffect(() => { onPendingChange(unresolved); return () => onPendingChange(false); }, [onPendingChange, unresolved]);
-  usePendingCloudInput(busy || Boolean(operation.current));
-  useEffect(() => {
-    let live = true;
-    const load = async () => {
-      let page = await cloudAgentsApi.call('threads', {});
-      while (page.next_offset !== null) { const next = await cloudAgentsApi.call('threads', { offset: page.next_offset }); page = { ...next, threads: [...page.threads, ...next.threads] }; }
-      if (live) setThreads(page.threads);
-    };
-    void load().catch(e => { if (live) setError(e instanceof Error ? e.message : '对话读取失败'); });
-    return () => { live = false; };
-  }, []);
-  useEffect(() => {
-    let live = true; setFiles([]); setFile('');
-    if (thread) cloudAgentsApi.call('attachments', { thread_id: thread }).then(page => { if (live) setFiles(page.attachments); }).catch(e => { if (live) setError(e instanceof Error ? e.message : '附件读取失败'); });
-    return () => { live = false; };
-  }, [thread]);
-  return <div className="space-y-3 rounded-lg border p-3">
-    <p className="text-xs text-muted-foreground">只显示你自己的对话附件。导入后自动处理，变为“可用于回答”后才能检索。</p>
-    <select aria-label="附件来源对话" className="h-10 w-full rounded-md border bg-background px-3" value={thread} disabled={busy || Boolean(operation.current)} onChange={e => setThread(e.target.value)}><option value="">选择对话</option>{threads.map(item => <option key={item.thread_id} value={item.thread_id}>{item.title || '未命名对话'}</option>)}</select>
-    <select aria-label="入库附件" className="h-10 w-full rounded-md border bg-background px-3" value={file} disabled={busy || Boolean(operation.current)} onChange={e => setFile(e.target.value)}><option value="">选择附件</option>{files.map(item => <option key={item.file_id} value={item.file_id}>{item.file_name}</option>)}</select>
-    <Button type="button" disabled={busy || !thread || !file} onClick={() => void act(async () => {
-      operation.current ??= crypto.randomUUID();
-      const result = await cloudAgentsApi.call('importKnowledgeAttachment', { slug, kb_id: kbId, thread_id: thread, attachment_id: file, operation_id: operation.current });
-      operation.current = null; await onImported(result);
-    })}>{busy ? '正在导入…' : operation.current ? '重试本次导入' : '确认导入知识库'}</Button>
-    {error && <p role="alert" className="text-destructive">{error}</p>}
-  </div>;
-}
diff --git a/src/pages/CloudAgents/CloudKnowledgeSelector.tsx b/src/pages/CloudAgents/CloudKnowledgeSelector.tsx
index 65ce7dd9..9888fb2e 100644
--- a/src/pages/CloudAgents/CloudKnowledgeSelector.tsx
+++ b/src/pages/CloudAgents/CloudKnowledgeSelector.tsx
@@ -1,5 +1,5 @@
 import { useState } from 'react';
-import { X } from 'lucide-react';
+import { Library, X } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { CloudKnowledgePanel, type CloudOwnedKnowledgeCatalog } from './CloudKnowledge';
 import type { CloudResource } from '../../../shared/cloud-agents';
@@ -16,7 +16,15 @@ export function CloudKnowledgeSelector({ slug, options, selected, disabled, load
   const unknown = ownedIds === null ? available : [];
   const selectionFull = selected.length >= 100;
   const add = (id: string) => { if (!selectionFull && !selected.includes(id)) onChange([...selected, id]); };
-  return <div className="space-y-3">
+  return <div className="agent-knowledge-workspace">
+    <CloudKnowledgePanel key={slug} slug={slug} disabled={disabled} onCatalog={setOwned} refreshToken={refreshToken}
+      selectionFull={selectionFull} selectedIds={selected} selectableIds={loading || error ? null : options.map(option => option.key)}
+      onSelected={kb => { if (!loading && !error && options.some(option => option.key === kb.kb_id)) { add(kb.kb_id); onRefresh(); } }}
+      onDeleted={id => { onChange(selected.filter(value => value !== id)); onRefresh(); }}
+      onCreated={kb => { add(kb.kb_id); onRefresh(); }} />
+    <section aria-label="选择知识库" className="agent-knowledge-selection space-y-4">
+    <div className="agent-knowledge-panel-heading"><Library aria-hidden="true" className="size-5" /><h3>选择知识库</h3></div>
+    <p className="text-xs leading-5 text-muted-foreground">从 MakeLore知识和我的知识库中选择，可同时使用多个。</p>
     <div className="flex flex-wrap items-center gap-2">
       <select aria-label="选择知识库" className="min-w-0 flex-1 basis-48" disabled={disabled || loading || Boolean(error) || selectionFull || available.length === 0} value=""
         onChange={event => { if (!disabled && !loading && !error && event.target.value && available.some(option => option.key === event.target.value)) add(event.target.value); }}>
@@ -50,10 +58,6 @@ export function CloudKnowledgeSelector({ slug, options, selected, disabled, load
       })}
     </ul> : <p className="agent-resource-empty">还没有选择知识库</p>}
     <p className="text-xs leading-5 text-muted-foreground">选择后保存并应用配置，智能体即可使用这些知识。MakeLore知识只可检索，无法在这里修改。</p>
-    <div className="agent-config-resource-manager"><CloudKnowledgePanel key={slug} slug={slug} disabled={disabled} onCatalog={setOwned} refreshToken={refreshToken}
-      selectionFull={selectionFull} selectedIds={selected} selectableIds={loading || error ? null : options.map(option => option.key)}
-      onSelected={kb => { if (!loading && !error && options.some(option => option.key === kb.kb_id)) { add(kb.kb_id); onRefresh(); } }}
-      onDeleted={id => { onChange(selected.filter(value => value !== id)); onRefresh(); }}
-      onCreated={kb => { add(kb.kb_id); onRefresh(); }} /></div>
+    </section>
   </div>;
 }
diff --git a/src/pages/CloudAgents/agent-config.css b/src/pages/CloudAgents/agent-config.css
index 7798a365..4995f0b9 100644
--- a/src/pages/CloudAgents/agent-config.css
+++ b/src/pages/CloudAgents/agent-config.css
@@ -41,6 +41,66 @@
 .agent-resource-preload { display: flex; min-height: 44px; align-items: center; gap: 9px; margin-top: 12px; cursor: pointer; font-size: 13px; }
 .agent-config-resource-manager { margin-top: 18px; }
 .agent-config-resource-manager > details { border-radius: 14px; background: #ffffffa8; }
+.agent-resource-card:has(.agent-knowledge-workspace) { container-type: inline-size; }
+.agent-knowledge-workspace { display: grid; grid-template-columns: minmax(0, 1.2fr) minmax(0, 1fr); align-items: start; gap: 18px; min-width: 0; }
+.agent-knowledge-upload, .agent-knowledge-selection { min-width: 0; padding: 18px; border: 1px solid #dce5e0; border-radius: 17px; background: #fffdfb; overflow-wrap: anywhere; }
+.agent-knowledge-upload { border-color: #dce5f3; }
+.agent-knowledge-panel-heading { display: flex; align-items: center; gap: 9px; color: #33485c; }
+.agent-knowledge-panel-heading h3 { font-size: 16px; font-weight: 650; line-height: 1.5; }
+.agent-knowledge-panel-heading svg { flex-shrink: 0; color: #607d72; }
+.agent-knowledge-upload .agent-knowledge-panel-heading svg { color: #4a6e9c; }
+.agent-knowledge-field-label { display: block; font-size: 13px; font-weight: 600; color: #4c586b; }
+.agent-knowledge-help { border-top: 1px solid #e8e6e1; padding-top: 12px; }
+.agent-knowledge-help summary { min-height: 28px; width: fit-content; cursor: pointer; color: #606c7e; font-size: 12px; line-height: 1.7; }
+.agent-knowledge-help summary:focus-visible { outline: 2px solid #9a7bb5; outline-offset: 3px; border-radius: 4px; }
+.agent-knowledge-selection ul { max-height: 480px; overflow: auto; overscroll-behavior: contain; }
+.agent-knowledge-selection button { flex-shrink: 0; }
+.agent-knowledge-import.agent-knowledge-import-modal { display: flex; flex-direction: column; width: calc(100vw - 32px); max-width: 860px; max-height: calc(100dvh - 32px); gap: 18px; border-radius: 22px; padding: 24px; background: #fffdf9; color: #273246; }
+.agent-knowledge-import-header { display: flex; align-items: flex-start; justify-content: space-between; gap: 12px; flex-shrink: 0; min-width: 0; }
+.agent-knowledge-import-header > div { min-width: 0; overflow-wrap: anywhere; }
+.agent-knowledge-import-header p { margin-top: 6px; line-height: 1.7; color: #59657a; }
+.agent-knowledge-import-content { display: flex; flex-direction: column; gap: 16px; min-height: 0; min-width: 0; overflow: auto; overscroll-behavior: contain; }
+.agent-knowledge-import-help { color: #606c7e; font-size: 13px; line-height: 1.7; overflow-wrap: anywhere; }
+.agent-knowledge-import-body { display: grid; grid-template-columns: minmax(0, 1fr) minmax(0, 1.3fr); gap: 16px; min-height: 0; min-width: 0; overflow: auto; }
+.agent-knowledge-import-content > .agent-knowledge-import-body { flex-shrink: 0; }
+.agent-knowledge-import-chats, .agent-knowledge-import-files { display: flex; flex-direction: column; min-width: 0; min-height: 0; gap: 10px; }
+.agent-knowledge-import-chats h3, .agent-knowledge-import-files h3 { font-size: 14px; font-weight: 600; }
+.agent-knowledge-import-search { display: flex; align-items: center; gap: 8px; min-width: 0; color: #606c7e; }
+.agent-knowledge-import-search svg, .agent-knowledge-import-file > svg { flex-shrink: 0; }
+.agent-knowledge-import :is(input:not([type="checkbox"]), select) { width: 100%; min-width: 0; min-height: 42px; border: 1px solid #cdd5e3; border-radius: 11px; background: #fff; padding: 10px 12px; font-size: 14px; }
+.agent-knowledge-import :is(input, button):focus-visible { outline: 2px solid #9a7bb5; outline-offset: 2px; }
+.agent-knowledge-import-chat-list, .agent-knowledge-import-file-list { min-width: 0; overflow: auto; max-height: 330px; overscroll-behavior: contain; border: 1px solid #dce2ec; border-radius: 13px; background: #fff; }
+.agent-knowledge-import-chat-list > :is(p, div), .agent-knowledge-import-file-list > :is(p, div) { padding: 14px; color: #606c7e; font-size: 13px; line-height: 1.7; }
+.agent-knowledge-import-chat { display: flex; flex-direction: column; gap: 5px; width: 100%; min-height: 68px; padding: 12px; text-align: left; font-size: 14px; line-height: 1.5; cursor: pointer; overflow-wrap: anywhere; transition: background-color 160ms ease; }
+.agent-knowledge-import-chat + .agent-knowledge-import-chat { border-top: 1px solid #edf0f5; }
+.agent-knowledge-import-chat:hover { background: #f6f5fa; }
+.agent-knowledge-import-chat[aria-pressed="true"] { background: #f1f6ff; box-shadow: inset 3px 0 #6b87b3; }
+.agent-knowledge-import-chat:disabled { cursor: not-allowed; }
+.agent-knowledge-import-chat small { color: #606c7e; font-size: 12px; }
+.agent-knowledge-import-file { display: flex; align-items: flex-start; gap: 10px; min-width: 0; min-height: 64px; padding: 12px; font-size: 14px; line-height: 1.6; cursor: pointer; overflow-wrap: anywhere; }
+.agent-knowledge-import-file + .agent-knowledge-import-file { border-top: 1px solid #edf0f5; }
+.agent-knowledge-import-file:has(input:checked) { background: #f6f2ff; }
+.agent-knowledge-import-file:has(input:disabled) { cursor: not-allowed; }
+.agent-knowledge-import-file input[type="checkbox"] { width: 17px; height: 17px; margin-top: 3px; accent-color: #79629d; flex-shrink: 0; }
+.agent-knowledge-import-file > span { min-width: 0; }
+.agent-knowledge-import-file small { display: block; font-size: 12px; color: #606c7e; }
+.agent-knowledge-import-selection { flex-shrink: 0; min-width: 0; border-radius: 12px; background: #f3f0f8; padding: 12px; font-size: 13px; overflow-wrap: anywhere; }
+.agent-knowledge-import-selection ul { max-height: 130px; overflow: auto; }
+.agent-knowledge-import-selection li { display: flex; justify-content: space-between; align-items: center; gap: 8px; padding-top: 8px; }
+.agent-knowledge-import-selection li > span { min-width: 0; }
+.agent-knowledge-import-selection li button { flex-shrink: 0; }
+.agent-knowledge-import-selection small { display: block; color: #606c7e; font-size: 12px; }
+.agent-knowledge-import-results { max-height: 170px; min-height: 0; flex-shrink: 0; overflow: auto; border: 1px solid #dce5e0; border-radius: 12px; padding: 12px; font-size: 13px; line-height: 1.7; overflow-wrap: anywhere; }
+.agent-knowledge-import-results li + li { border-top: 1px solid #e8e6e1; margin-top: 10px; padding-top: 10px; }
+.agent-knowledge-import-results li > span { display: flex; align-items: center; gap: 6px; }
+.agent-knowledge-import-results li > span + span { color: #526c5f; }
+.agent-knowledge-import-results [role="alert"] { color: #b54532; }
+.agent-knowledge-import-abandon { flex-shrink: 0; padding: 12px; border: 1px solid #efd9ba; border-radius: 12px; background: #fff5e9; font-size: 13px; line-height: 1.7; }
+.agent-knowledge-import-abandon p { margin-bottom: 10px; }
+.agent-knowledge-import-abandon button { margin: 0 8px 6px 0; }
+.agent-knowledge-import-footer { display: flex; flex-wrap: wrap; justify-content: flex-end; align-items: center; gap: 9px; flex-shrink: 0; }
+.agent-knowledge-import-footer p { flex: 1 1 280px; min-width: 0; font-size: 12px; line-height: 1.7; color: #606c7e; }
+@container (max-width: 620px) { .agent-knowledge-workspace { grid-template-columns: minmax(0, 1fr); } }
 @media (max-width: 640px) {
   .agent-editor-tabs { padding: 10px 12px; }
   .agent-editor-tabs [role="tab"] { gap: 6px; padding-inline: 8px; font-size: 14px; }
@@ -52,5 +112,12 @@
   .agent-config-heading-title { gap: 6px; }
   .agent-config-icon { width: 38px; height: 38px; border-radius: 13px; }
   .agent-config-section-top > button { margin-left: 48px; }
+  .agent-knowledge-workspace { grid-template-columns: minmax(0, 1fr); gap: 14px; }
+  .agent-knowledge-upload, .agent-knowledge-selection { padding: 14px; border-radius: 14px; }
+  .agent-knowledge-import.agent-knowledge-import-modal { padding: 18px; border-radius: 18px; gap: 14px; }
+  .agent-knowledge-import-body { grid-template-columns: minmax(0, 1fr); }
+  .agent-knowledge-import-chat-list { max-height: 160px; }
+  .agent-knowledge-import-file-list { max-height: 240px; }
+  .agent-knowledge-import-footer button { width: 100%; }
 }
-@media (prefers-reduced-motion: reduce) { .agent-resource-option { transition: none; } }
+@media (prefers-reduced-motion: reduce) { .agent-resource-option, .agent-knowledge-import-chat { transition: none; } }
diff --git a/tests/e2e/cloud-agent-knowledge.spec.ts b/tests/e2e/cloud-agent-knowledge.spec.ts
index 9389f2b0..f1007d28 100644
--- a/tests/e2e/cloud-agent-knowledge.spec.ts
+++ b/tests/e2e/cloud-agent-knowledge.spec.ts
@@ -1,20 +1,36 @@
 import { test, expect, type Page } from '@playwright/test';
-import { createServer, type ViteDevServer } from 'vite';
-import { resolve } from 'node:path';
-import { EMPTY_CLOUD_CONFIGURATION, type CloudAgentDraft, type CloudKnowledge, type CloudKnowledgeFile } from '../../shared/cloud-agents';
+import { build } from 'vite';
+import { createServer, type Server } from 'node:http';
+import { mkdtemp, readFile, realpath, rm, symlink, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve, sep } from 'node:path';
+import { createRequire } from 'node:module';
+import { EMPTY_CLOUD_CONFIGURATION, type CloudAgentDraft, type CloudKnowledge, type CloudKnowledgeFile, type CloudThread, type CloudAttachment } from '../../shared/cloud-agents';
 
-let server: ViteDevServer;
+let server: Server;
 let baseUrl: string;
+let fixtureDir: string;
+const fixtureRequire = createRequire(resolve('tests/e2e/cloud-agent-knowledge.spec.ts'));
+const viteDependencies = createRequire(fixtureRequire.resolve('vite/package.json'));
 test.use({ headless: true, channel: process.env.MAKELORE_LAYOUT_BROWSER_CHANNEL, video: 'off' });
 
 // Render the real editor while replacing only the Main IPC boundary. No Electron,
 // native picker, real upload or cloud request is started by this suite.
 test.beforeAll(async () => {
+  test.setTimeout(90_000);
+  fixtureDir = await realpath(await mkdtemp(join(tmpdir(), 'makelore-knowledge-fixture-')));
+  await symlink(resolve('node_modules'), join(fixtureDir, 'node_modules'), 'dir');
+  const html = join(fixtureDir, 'index.html');
+  const output = join(fixtureDir, 'dist');
+  await writeFile(html, '<!doctype html><html><head><meta charset="utf-8"></head><body><div id="root"></div><script type="module" src="/__cloud-agent-knowledge-harness.tsx"></script></body></html>');
   const entry = resolve('tests/e2e/__cloud-agent-knowledge-harness.tsx');
-  server = await createServer({
-    configFile: false, cacheDir: 'node_modules/.vite-cloud-agent-knowledge',
+  // Build the virtual entry once. A static fixture needs no Vite dev server,
+  // background dependency discovery, file watcher, or HMR connection.
+  await build({
+    configFile: false, root: fixtureDir, publicDir: false, logLevel: 'warn',
     resolve: { alias: { '@': resolve('src') } }, esbuild: { jsx: 'automatic' },
-    server: { host: '127.0.0.1', port: 0 },
+    css: { postcss: resolve('.') },
+    build: { outDir: output, emptyOutDir: true, rollupOptions: { input: html } },
     plugins: [{
       name: 'isolated-cloud-agent-knowledge', enforce: 'pre',
       resolveId(id) { if (id === '/__cloud-agent-knowledge-harness.tsx') return entry; },
@@ -22,25 +38,37 @@ test.beforeAll(async () => {
         if (id === entry) return `
           import { createRoot } from 'react-dom/client';
           import { createMemoryRouter, RouterProvider } from 'react-router-dom';
-          import CloudAgents from '/src/pages/CloudAgents/index.tsx';
-          import '/src/styles/globals.css';
+          import CloudAgents from ${JSON.stringify(resolve('src/pages/CloudAgents/index.tsx'))};
+          import ${JSON.stringify(resolve('src/styles/globals.css'))};
           const router = createMemoryRouter([{ path: '/cloud-agents', element: <CloudAgents /> }], { initialEntries: ['/cloud-agents?view=mine'] });
           createRoot(document.getElementById('root')).render(<div className="h-screen min-w-0"><RouterProvider router={router} /></div>);
         `;
         if (id.endsWith('/src/stores/auth.ts')) return 'export function useAuthStore(select) { return select({ user: { userId: "knowledge-fixture" } }); }';
       },
-      configureServer(vite) {
-        vite.middlewares.use((req, res, next) => {
-          if (req.url !== '/' && !req.url?.startsWith('/?')) return next();
-          res.setHeader('Content-Type', 'text/html');
-          res.end('<!doctype html><html><head><meta charset="utf-8"></head><body><div id="root"></div><script type="module" src="/__cloud-agent-knowledge-harness.tsx"></script></body></html>');
-        });
-      },
     }],
   });
-  await server.listen(); baseUrl = server.resolvedUrls!.local[0];
+  const mime: Record<string, string> = { html: 'text/html', js: 'text/javascript', css: 'text/css',
+    svg: 'image/svg+xml', png: 'image/png', woff2: 'font/woff2', woff: 'font/woff' };
+  server = createServer(async (req, res) => {
+    const pathname = decodeURIComponent(new URL(req.url ?? '/', 'http://127.0.0.1').pathname);
+    const file = resolve(output, '.' + (pathname === '/' ? '/index.html' : pathname));
+    if (!file.startsWith(output + sep)) { res.writeHead(403); res.end(); return; }
+    try { const bytes = await readFile(file); res.setHeader('Content-Type', mime[file.split('.').pop()!] ?? 'application/octet-stream'); res.end(bytes); }
+    catch { res.writeHead(404); res.end(); }
+  });
+  await new Promise<void>((done, reject) => { server.once('error', reject); server.listen(0, '127.0.0.1', done); });
+  const address = server.address();
+  if (!address || typeof address === 'string') throw new Error('Fixture HTTP address is unavailable');
+  baseUrl = `http://127.0.0.1:${address.port}`;
+});
+test.afterAll(async () => {
+  try {
+    if (server?.listening) { server.closeAllConnections(); await new Promise<void>((done, reject) => server.close(error => error ? reject(error) : done())); }
+  } finally {
+    try { if (fixtureDir) await rm(fixtureDir, { recursive: true, force: true }); }
+    finally { (viteDependencies('esbuild') as { stop(): void }).stop(); }
+  }
 });
-test.afterAll(async () => { await server?.close(); });
 
 const agent: CloudAgentDraft = {
   slug: 'ml-' + 'a'.repeat(32), name: '资料小助手', purpose: '用我的资料回答问题。',
@@ -54,20 +82,37 @@ const libraries: CloudKnowledge[] = [
   { kb_id: 'kb_fixturereading', name: '阅读知识', description: '平台开放的阅读资料', embedding_model: 'fixture-embedding' },
   { kb_id: 'kb_fixturepersonal', name: '我的观察记录', description: '自己的资料', embedding_model: 'fixture-embedding' },
 ];
+const sourceThreads: CloudThread[] = [
+  { thread_id: 'thread-spring', client_thread_id: 'client-spring', agent_slug: agent.slug, title: '春天的观察讨论', mode: 'preview',
+    updated_at: '2026-10-13T01:00:00Z', run_id: null, status: 'completed', unread: false },
+  { thread_id: 'thread-reading', client_thread_id: 'client-reading', agent_slug: agent.slug, title: '图书阅读记录', mode: 'preview',
+    updated_at: '2026-10-13T00:00:00Z', run_id: null, status: 'completed', unread: false },
+];
+const sourceAttachments: Record<string, CloudAttachment[]> = {
+  'thread-spring': [
+    { file_id: 'attachment-observations', file_name: '春天观察报告.md', file_size: 1536, path: 'attachments/spring/report.md', original_path: 'attachments/spring/report.md' },
+    { file_id: 'attachment-plants', file_name: '植物清单.csv', file_size: 2048, path: 'attachments/spring/plants.csv', original_path: 'attachments/spring/plants.csv' },
+  ],
+  'thread-reading': [
+    { file_id: 'attachment-reading', file_name: '阅读笔记.pdf', file_size: 2048, path: 'attachments/reading/notes.pdf', original_path: 'attachments/reading/notes.pdf' },
+  ],
+};
 type FixtureCall = { path: string; method: string; input: Record<string, unknown> | null };
 type KnowledgeFixture = {
   agent: CloudAgentDraft; libraries: CloudKnowledge[]; files: Record<string, CloudKnowledgeFile[]>;
   calls: FixtureCall[]; ownedIds: string[]; upload: 'success' | 'cancel' | 'fail'; processFailure: boolean;
+  threads: CloudThread[]; attachments: Record<string, CloudAttachment[]>; importFailures: string[];
 };
 type FixtureWindow = Window & { __knowledgeFixture: KnowledgeFixture };
 
 async function installFixture(page: Page) {
   page.on('pageerror', error => { throw error; });
-  await page.addInitScript(({ agent, libraries }) => {
+  await page.addInitScript(({ agent, libraries, sourceThreads, sourceAttachments }) => {
     const scope = window as unknown as FixtureWindow;
     const stored = sessionStorage.getItem('knowledge-fixture');
     const state: KnowledgeFixture = stored ? JSON.parse(stored) : {
       agent, libraries, files: {}, calls: [], ownedIds: ['kb_fixturepersonal'], upload: 'success', processFailure: false,
+      threads: sourceThreads, attachments: sourceAttachments, importFailures: [],
     };
     scope.__knowledgeFixture = state;
     const persist = () => sessionStorage.setItem('knowledge-fixture', JSON.stringify(state));
@@ -113,6 +158,19 @@ async function installFixture(page: Page) {
           case 'knowledgeFiles':
             if (!managed(args?.kb_id)) throw new Error('Document management reached a read-only library');
             return result({ files: state.files[String(args?.kb_id)] ?? [], next_offset: null });
+          case 'threads': return result({ threads: state.threads, next_offset: null });
+          case 'received': return result({ agents: [] });
+          case 'attachments': return result({ attachments: state.attachments[String(args?.thread_id)] ?? [] });
+          case 'importKnowledgeAttachment': {
+            if (!managed(args?.kb_id)) throw new Error('Attachment import reached a read-only library');
+            const attachment = state.attachments[String(args?.thread_id)]?.find(file => file.file_id === args?.attachment_id);
+            if (!attachment) throw new Error('Unknown fixture source attachment');
+            if (state.importFailures.includes(attachment.file_id)) return failure('植物清单导入暂时失败');
+            const file: CloudKnowledgeFile = { file_id: 'imported-' + attachment.file_id, name: attachment.file_name,
+              size: attachment.file_size, status: 'uploaded', error: null, chunk_count: 0, available: false };
+            state.files[String(args?.kb_id)] = [file, ...(state.files[String(args?.kb_id)] ?? []).filter(item => item.file_id !== file.file_id)];
+            return result(file);
+          }
           case 'processKnowledge': {
             if (!managed(args?.kb_id)) throw new Error('Processing reached a read-only library');
             if (state.processFailure) return failure('处理请求暂不可用');
@@ -125,7 +183,7 @@ async function installFixture(page: Page) {
         }
       },
     } } });
-  }, { agent, libraries });
+  }, { agent, libraries, sourceThreads, sourceAttachments });
 }
 
 async function openKnowledge(page: Page) {
@@ -150,6 +208,36 @@ async function expectNoClipping(page: Page) {
   });
   expect(clipped).toEqual([]);
 }
+async function expectKnowledgeLayout(page: Page, width: number) {
+  const layout = page.locator('.agent-knowledge-workspace');
+  const upload = await layout.locator('.agent-knowledge-upload').boundingBox();
+  const selection = await layout.locator('.agent-knowledge-selection').boundingBox();
+  expect(upload).not.toBeNull(); expect(selection).not.toBeNull();
+  if (width >= 1024) {
+    expect(upload!.x + upload!.width).toBeLessThanOrEqual(selection!.x + 1);
+    expect(Math.abs(upload!.y - selection!.y)).toBeLessThanOrEqual(1);
+  } else {
+    expect(upload!.y + upload!.height).toBeLessThanOrEqual(selection!.y + 1);
+    expect(Math.abs(upload!.x - selection!.x)).toBeLessThanOrEqual(1);
+  }
+  await expectNoClipping(page);
+}
+async function expectPickerBounds(page: Page) {
+  expect(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth)).toBe(true);
+  const outside = await page.getByRole('dialog', { name: '从聊天选择文件', exact: true }).evaluate(dialog => {
+    const bounds = dialog.getBoundingClientRect();
+    return {
+      bounds: { left: bounds.left, top: bounds.top, right: bounds.right, bottom: bounds.bottom },
+      viewport: { width: innerWidth, height: innerHeight },
+      dialogFits: bounds.left >= 0 && bounds.top >= 0 && bounds.right <= innerWidth && bounds.bottom <= innerHeight,
+      clipped: [...dialog.querySelectorAll('button, input, label, h2, h4')].filter(element => element.getClientRects().length > 0)
+        .filter(element => { const box = element.getBoundingClientRect(); return box.left < bounds.left - 1 || box.right > bounds.right + 1; })
+        .map(element => element.getAttribute('aria-label') ?? element.textContent?.trim()),
+    };
+  });
+  expect(outside.dialogFits, JSON.stringify(outside)).toBe(true); expect(outside.clipped).toEqual([]);
+  if (outside.viewport.width >= 1024) expect(outside.bounds.right - outside.bounds.left).toBeGreaterThanOrEqual(800);
+}
 
 for (const width of [375, 1440]) {
   test(`multiple shared/personal choices stay draft-only and survive save/reopen at ${width}px`, async ({ page }) => {
@@ -168,11 +256,11 @@ for (const width of [375, 1440]) {
     await expect(selected.getByRole('button', { name: '移除知识库 科学知识', exact: true })).toBeVisible();
     await expect(selected.getByRole('button', { name: /上传|删除|处理|替换/ })).toHaveCount(0);
     expect((await calls(page)).filter(call => call.method === 'PATCH' || call.path.endsWith('/knowledge/pick'))).toEqual([]);
-    await knowledge.getByText('上传自己的文件', { exact: true }).click();
+    await expect(knowledge.getByRole('heading', { name: '上传自己的文件', exact: true })).toBeVisible();
     const management = knowledge.getByRole('combobox', { name: '管理的知识库', exact: true });
     await expect(management.locator('option[value="kb_fixturescience"], option[value="kb_fixturereading"]')).toHaveCount(0);
-    await expect(knowledge.getByRole('button', { name: '上传文档', exact: true })).toHaveCount(0);
-    await expectNoClipping(page); await page.screenshot({ path: test.info().outputPath(`knowledge-shared-${width}.png`), animations: 'disabled' });
+    await expect(knowledge.getByRole('button', { name: '从电脑上传', exact: true })).toHaveCount(0);
+    await expectKnowledgeLayout(page, width); await page.screenshot({ path: test.info().outputPath(`knowledge-shared-${width}.png`), animations: 'disabled' });
     await editor.getByRole('button', { name: '保存草稿', exact: true }).click();
     await expect(editor.getByRole('button', { name: '已保存', exact: true })).toBeVisible();
     expect((await calls(page)).filter(call => call.method === 'PATCH').map(call => (call.input?.configuration as { knowledges: string[] }).knowledges))
@@ -186,7 +274,7 @@ for (const width of [375, 1440]) {
     await page.setViewportSize({ width, height: 850 }); await installFixture(page); await page.goto(baseUrl);
     const { editor, knowledge } = await openKnowledge(page);
     await knowledge.getByRole('combobox', { name: '选择知识库', exact: true }).selectOption('kb_fixturescience');
-    await knowledge.getByText('上传自己的文件', { exact: true }).click();
+    await expect(knowledge.getByRole('heading', { name: '上传自己的文件', exact: true })).toBeVisible();
     expect((await calls(page)).filter(call => call.path.endsWith('/knowledge/pick') || ['createKnowledge', 'processKnowledge'].includes(String(call.input?.operation)))).toEqual([]);
     await knowledge.getByRole('button', { name: '新建知识库', exact: true }).click();
     await knowledge.getByRole('textbox', { name: '知识库名称', exact: true }).fill('我的春天资料');
@@ -195,7 +283,7 @@ for (const width of [375, 1440]) {
     await expect(knowledge.getByRole('combobox', { name: '管理的知识库', exact: true })).toHaveValue('kb_fixturecreated');
     await expect(knowledge.getByRole('list', { name: '已选知识库', exact: true })).toContainText('我的春天资料');
     expect((await calls(page)).filter(call => call.path.endsWith('/knowledge/pick') || call.input?.operation === 'processKnowledge')).toEqual([]);
-    await knowledge.getByRole('button', { name: '上传文档', exact: true }).click();
+    await knowledge.getByRole('button', { name: '从电脑上传', exact: true }).click();
     const document = knowledge.getByRole('article', { name: '春天观察记录.md', exact: true });
     await expect(document.getByText('等待处理', { exact: true })).toBeVisible();
     const mutations = (await calls(page)).filter(call => call.path.endsWith('/knowledge/pick') || call.input?.operation === 'processKnowledge');
@@ -210,7 +298,7 @@ for (const width of [375, 1440]) {
     await expect(document.getByText('可用于回答', { exact: true })).toBeVisible({ timeout: 12_000 });
     await expect(document.getByText('2 KB · 6 段可检索内容', { exact: true })).toBeVisible();
     await document.scrollIntoViewIfNeeded();
-    await expectNoClipping(page); await page.screenshot({ path: test.info().outputPath(`knowledge-upload-ready-${width}.png`), animations: 'disabled' });
+    await expectKnowledgeLayout(page, width); await page.screenshot({ path: test.info().outputPath(`knowledge-upload-ready-${width}.png`), animations: 'disabled' });
     // Document mutations never implicitly save the Agent draft.
     expect((await calls(page)).filter(call => call.method === 'PATCH')).toEqual([]);
     await editor.getByRole('button', { name: '保存草稿', exact: true }).click();
@@ -218,6 +306,52 @@ for (const width of [375, 1440]) {
     expect(await page.evaluate(() => (window as unknown as FixtureWindow).__knowledgeFixture.agent.configuration.knowledges))
       .toEqual(['kb_fixturescience', 'kb_fixturecreated']);
   });
+
+  test(`chat files show their source and metadata and import multiple choices into the named own library at ${width}px`, async ({ page }) => {
+    await page.setViewportSize({ width, height: 850 }); await installFixture(page); await page.goto(baseUrl);
+    const { knowledge } = await openKnowledge(page);
+    await knowledge.getByRole('combobox', { name: '选择知识库', exact: true }).selectOption('kb_fixturescience');
+    await knowledge.getByRole('combobox', { name: '管理的知识库', exact: true }).selectOption('kb_fixturepersonal');
+    await knowledge.getByRole('button', { name: '从聊天选择文件', exact: true }).click();
+    const picker = page.getByRole('dialog', { name: '从聊天选择文件', exact: true });
+    await expect(picker).toContainText('导入到「我的观察记录」');
+    await picker.getByRole('textbox', { name: '搜索对话', exact: true }).fill('春天');
+    await expect(picker.getByRole('button', { name: '选择对话 图书阅读记录', exact: true })).toHaveCount(0);
+    await picker.getByRole('button', { name: '选择对话 春天的观察讨论', exact: true }).click();
+    await expect(picker.getByRole('checkbox', { name: '选择文件 春天观察报告.md', exact: true })).toBeVisible();
+    await expect(picker.locator('.agent-knowledge-import-file').filter({ has: page.getByRole('checkbox', { name: '选择文件 春天观察报告.md', exact: true }) }))
+      .toContainText(/(?:MD|Markdown)\s*·\s*(?:1\.5|2)\s*KB/i);
+    await picker.getByRole('textbox', { name: '搜索文件', exact: true }).fill('植物');
+    await expect(picker.getByRole('checkbox', { name: '选择文件 春天观察报告.md', exact: true })).toHaveCount(0);
+    await picker.getByRole('checkbox', { name: '选择文件 植物清单.csv', exact: true }).check();
+    await expect(picker.locator('.agent-knowledge-import-file').filter({ has: page.getByRole('checkbox', { name: '选择文件 植物清单.csv', exact: true }) }))
+      .toContainText(/CSV\s*·\s*2\s*KB/);
+    await picker.getByRole('textbox', { name: '搜索文件', exact: true }).fill('');
+    await picker.getByRole('checkbox', { name: '选择文件 春天观察报告.md', exact: true }).check();
+    await picker.getByRole('textbox', { name: '搜索对话', exact: true }).fill('图书');
+    await picker.getByRole('button', { name: '选择对话 图书阅读记录', exact: true }).click();
+    await picker.getByRole('checkbox', { name: '选择文件 阅读笔记.pdf', exact: true }).check();
+    const confirm = picker.getByRole('button', { name: '导入 3 个文件', exact: true });
+    await expect(confirm).toBeEnabled();
+    await expect(confirm).toBeInViewport();
+    expect((await calls(page)).filter(call => ['importKnowledgeAttachment', 'processKnowledge'].includes(String(call.input?.operation)))).toEqual([]);
+    await expectPickerBounds(page);
+    await page.screenshot({ path: test.info().outputPath(`knowledge-chat-picker-${width}.png`), animations: 'disabled' });
+    await confirm.click();
+    await expect(picker).toHaveCount(0);
+    for (const name of ['春天观察报告.md', '植物清单.csv', '阅读笔记.pdf']) {
+      await expect(knowledge.getByRole('article', { name, exact: true })).toBeVisible();
+    }
+    const imports = (await calls(page)).filter(call => call.input?.operation === 'importKnowledgeAttachment');
+    expect(imports).toHaveLength(3);
+    expect(imports.map(call => (call.input?.input as { attachment_id: string }).attachment_id).sort())
+      .toEqual(['attachment-observations', 'attachment-plants', 'attachment-reading']);
+    expect(imports.every(call => (call.input?.input as { kb_id: string }).kb_id === 'kb_fixturepersonal')).toBe(true);
+    expect((await calls(page)).filter(call => call.input?.operation === 'processKnowledge')).toHaveLength(3);
+    expect((await calls(page)).filter(call => call.method === 'PATCH')).toEqual([]);
+    await expect(knowledge.getByRole('list', { name: '已选知识库', exact: true })).toContainText('科学知识');
+    await expectKnowledgeLayout(page, width);
+  });
 }
 
 test('cancelled and failed uploads preserve shared choices and the personal draft', async ({ page }) => {
@@ -227,15 +361,15 @@ test('cancelled and failed uploads preserve shared choices and the personal draf
   await editor.getByRole('textbox', { name: '提示词', exact: true }).fill('这是我还没有保存的提示词。');
   await editor.getByRole('tab', { name: '高级设置', exact: true }).click();
   await knowledge.getByRole('combobox', { name: '选择知识库', exact: true }).selectOption('kb_fixturescience');
-  await knowledge.getByText('上传自己的文件', { exact: true }).click();
+  await expect(knowledge.getByRole('heading', { name: '上传自己的文件', exact: true })).toBeVisible();
   await knowledge.getByRole('combobox', { name: '管理的知识库', exact: true }).selectOption('kb_fixturepersonal');
   await page.evaluate(() => { (window as unknown as FixtureWindow).__knowledgeFixture.upload = 'cancel'; });
-  await knowledge.getByRole('button', { name: '上传文档', exact: true }).click();
-  await expect(knowledge.getByRole('button', { name: '上传文档', exact: true })).toBeEnabled();
+  await knowledge.getByRole('button', { name: '从电脑上传', exact: true }).click();
+  await expect(knowledge.getByRole('button', { name: '从电脑上传', exact: true })).toBeEnabled();
   await expect(knowledge.getByRole('article')).toHaveCount(0);
   expect((await calls(page)).filter(call => call.input?.operation === 'processKnowledge')).toEqual([]);
   await page.evaluate(() => { (window as unknown as FixtureWindow).__knowledgeFixture.upload = 'fail'; });
-  await knowledge.getByRole('button', { name: '上传文档', exact: true }).click();
+  await knowledge.getByRole('button', { name: '从电脑上传', exact: true }).click();
   await expect(knowledge.getByRole('alert')).toContainText('上传服务暂不可用');
   await expect(knowledge.getByRole('combobox', { name: '管理的知识库', exact: true })).toHaveValue('kb_fixturepersonal');
   await expect(knowledge.getByRole('list', { name: '已选知识库', exact: true })).toContainText('科学知识');
@@ -255,3 +389,93 @@ test('cancelled and failed uploads preserve shared choices and the personal draf
   await editor.getByRole('tab', { name: '介绍与提示词', exact: true }).click();
   await expect(editor.getByRole('textbox', { name: '提示词', exact: true })).toHaveValue('这是我还没有保存的提示词。');
 });
+
+test('a partial chat-file import retries only the failed file with the same operation identity', async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 850 }); await installFixture(page); await page.goto(baseUrl);
+  const { knowledge } = await openKnowledge(page);
+  await knowledge.getByRole('combobox', { name: '选择知识库', exact: true }).selectOption('kb_fixturescience');
+  await knowledge.getByRole('combobox', { name: '管理的知识库', exact: true }).selectOption('kb_fixturepersonal');
+  await page.evaluate(() => { (window as unknown as FixtureWindow).__knowledgeFixture.importFailures = ['attachment-plants']; });
+  await knowledge.getByRole('button', { name: '从聊天选择文件', exact: true }).click();
+  const picker = page.getByRole('dialog', { name: '从聊天选择文件', exact: true });
+  await picker.getByRole('button', { name: '选择对话 春天的观察讨论', exact: true }).click();
+  await picker.getByRole('checkbox', { name: '选择文件 春天观察报告.md', exact: true }).check();
+  await picker.getByRole('checkbox', { name: '选择文件 植物清单.csv', exact: true }).check();
+  const confirm = picker.getByRole('button', { name: '导入 2 个文件', exact: true });
+  await expect(confirm).toBeInViewport();
+  await confirm.click({ timeout: 15_000 });
+  await expect(picker).toContainText('植物清单导入暂时失败');
+  const retry = picker.getByRole('button', { name: '重试失败的 1 个文件', exact: true });
+  await expect(retry).toBeEnabled();
+  await expect(retry).toBeInViewport();
+  await expect(picker.getByRole('button', { name: '关闭文件选择', exact: true })).toBeDisabled();
+  await page.keyboard.press('Escape');
+  await expect(picker).toBeVisible();
+  const originalImports = (await calls(page)).filter(call => call.input?.operation === 'importKnowledgeAttachment');
+  expect(originalImports).toHaveLength(2);
+  await expect(picker.getByRole('list', { name: '文件导入结果', exact: true }).getByRole('listitem').filter({ hasText: '春天观察报告.md' }))
+    .toContainText('已导入，处理状态见知识库');
+  await expectPickerBounds(page);
+  await page.screenshot({ path: test.info().outputPath('knowledge-chat-partial-failure-375.png'), animations: 'disabled' });
+  await page.evaluate(() => { (window as unknown as FixtureWindow).__knowledgeFixture.importFailures = []; });
+  await retry.click(); await expect(picker).toHaveCount(0);
+  await expect(knowledge.getByRole('article', { name: '春天观察报告.md', exact: true })).toBeVisible();
+  await expect(knowledge.getByRole('article', { name: '植物清单.csv', exact: true })).toBeVisible();
+  const imported = (await calls(page)).filter(call => call.input?.operation === 'importKnowledgeAttachment')
+    .map(call => call.input?.input as { attachment_id: string; operation_id: string; kb_id: string });
+  expect(imported.filter(input => input.attachment_id === 'attachment-observations')).toHaveLength(1);
+  const retried = imported.filter(input => input.attachment_id === 'attachment-plants');
+  expect(retried).toHaveLength(2); expect(new Set(retried.map(input => input.operation_id)).size).toBe(1);
+  expect(imported.every(input => input.kb_id === 'kb_fixturepersonal')).toBe(true);
+  const processed = (await calls(page)).filter(call => call.input?.operation === 'processKnowledge')
+    .map(call => (call.input?.input as { file_id: string }).file_id);
+  expect(processed.sort()).toEqual(['imported-attachment-observations', 'imported-attachment-plants']);
+  expect((await calls(page)).filter(call => call.method === 'PATCH')).toEqual([]);
+  await expect(knowledge.getByRole('list', { name: '已选知识库', exact: true })).toContainText('科学知识');
+  await expectNoClipping(page);
+});
+
+test('abandoning a failed batch keeps saved files and allows a fresh picker operation without replaying successes', async ({ page }) => {
+  await page.setViewportSize({ width: 375, height: 850 }); await installFixture(page); await page.goto(baseUrl);
+  const { knowledge } = await openKnowledge(page);
+  await knowledge.getByRole('combobox', { name: '选择知识库', exact: true }).selectOption('kb_fixturescience');
+  await knowledge.getByRole('combobox', { name: '管理的知识库', exact: true }).selectOption('kb_fixturepersonal');
+  await page.evaluate(() => { (window as unknown as FixtureWindow).__knowledgeFixture.importFailures = ['attachment-plants']; });
+  await knowledge.getByRole('button', { name: '从聊天选择文件', exact: true }).click();
+  const picker = page.getByRole('dialog', { name: '从聊天选择文件', exact: true });
+  await picker.getByRole('button', { name: '选择对话 春天的观察讨论', exact: true }).click();
+  await picker.getByRole('checkbox', { name: '选择文件 春天观察报告.md', exact: true }).check();
+  await picker.getByRole('checkbox', { name: '选择文件 植物清单.csv', exact: true }).check();
+  await expect(picker.getByRole('button', { name: '导入 2 个文件', exact: true })).toBeInViewport();
+  await picker.getByRole('button', { name: '导入 2 个文件', exact: true }).click({ timeout: 15_000 });
+  await expect(picker.getByRole('button', { name: '重试失败的 1 个文件', exact: true })).toBeEnabled();
+  const importsBefore = (await calls(page)).filter(call => call.input?.operation === 'importKnowledgeAttachment');
+  await picker.getByRole('button', { name: '放弃重试', exact: true }).click();
+  await expect(picker).toContainText('已保存的文件会保留');
+  const abandon = picker.getByRole('button', { name: '确认放弃重试', exact: true });
+  await abandon.scrollIntoViewIfNeeded(); await expect(abandon).toBeInViewport();
+  await expectPickerBounds(page);
+  await page.screenshot({ path: test.info().outputPath('knowledge-chat-abandon-confirm-375.png'), animations: 'disabled' });
+  await abandon.click(); await expect(picker).toHaveCount(0);
+  expect((await calls(page)).filter(call => call.input?.operation === 'importKnowledgeAttachment')).toEqual(importsBefore);
+  expect((await calls(page)).filter(call => /delete/i.test(String(call.input?.operation)) || call.method === 'DELETE')).toEqual([]);
+  await expect(knowledge.getByRole('article', { name: '春天观察报告.md', exact: true })).toBeVisible();
+  await expect(knowledge.getByRole('combobox', { name: '管理的知识库', exact: true })).toBeEnabled();
+  await page.evaluate(() => { (window as unknown as FixtureWindow).__knowledgeFixture.importFailures = []; });
+  await knowledge.getByRole('button', { name: '从聊天选择文件', exact: true }).click();
+  await picker.getByRole('button', { name: '选择对话 春天的观察讨论', exact: true }).click();
+  await expect(picker.getByRole('checkbox', { name: '选择文件 春天观察报告.md', exact: true })).not.toBeChecked();
+  await picker.getByRole('checkbox', { name: '选择文件 植物清单.csv', exact: true }).check();
+  await picker.getByRole('button', { name: '导入 1 个文件', exact: true }).click();
+  await expect(picker).toHaveCount(0);
+  const imports = (await calls(page)).filter(call => call.input?.operation === 'importKnowledgeAttachment')
+    .map(call => call.input?.input as { attachment_id: string; operation_id: string });
+  expect(imports.filter(input => input.attachment_id === 'attachment-observations')).toHaveLength(1);
+  const plants = imports.filter(input => input.attachment_id === 'attachment-plants');
+  expect(plants).toHaveLength(2); expect(new Set(plants.map(input => input.operation_id)).size).toBe(2);
+  const processed = (await calls(page)).filter(call => call.input?.operation === 'processKnowledge')
+    .map(call => (call.input?.input as { file_id: string }).file_id);
+  expect(processed.sort()).toEqual(['imported-attachment-observations', 'imported-attachment-plants']);
+  await expect(knowledge.getByRole('list', { name: '已选知识库', exact: true })).toContainText('科学知识');
+  await expectNoClipping(page);
+});
diff --git a/tests/unit/cloud-knowledge-import.test.tsx b/tests/unit/cloud-knowledge-import.test.tsx
new file mode 100644
index 00000000..8b93b62a
--- /dev/null
+++ b/tests/unit/cloud-knowledge-import.test.tsx
@@ -0,0 +1,345 @@
+import { act, cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
+import { afterEach, beforeEach, expect, it, vi } from 'vitest';
+import { CloudKnowledgeAttachmentPicker } from '@/pages/CloudAgents/CloudKnowledgeAttachmentPicker';
+import { CloudKnowledgePanel } from '@/pages/CloudAgents/CloudKnowledge';
+import type { CloudAttachment, CloudKnowledgeFile, CloudThread } from '../../shared/cloud-agents';
+
+const api = vi.hoisted(() => ({ call: vi.fn(), list: vi.fn() }));
+vi.mock('@/lib/cloud-agents-api', () => ({ cloudAgentsApi: api }));
+const slug = 'ml-' + 'a'.repeat(32), otherSlug = 'ml-' + 'b'.repeat(32);
+const threads: CloudThread[] = [
+  { thread_id: 'spring', title: '春天的观察讨论', agent_slug: slug, client_thread_id: null, updated_at: '2026-10-13T00:00:00Z', mode: 'published', run_id: null, status: 'completed', unread: false },
+  { thread_id: 'reading', title: '图书阅读记录', agent_slug: otherSlug, client_thread_id: null, updated_at: '2026-10-12T00:00:00Z', mode: 'preview', run_id: null, status: 'completed', unread: false },
+];
+function attachment(id: string, name: string, size = 1536): CloudAttachment {
+  return { file_id: id, file_name: name, file_size: size, path: '/attachments/' + name, original_path: '/attachments/' + name };
+}
+function knowledgeFile(id: string): CloudKnowledgeFile {
+  return { file_id: 'knowledge-' + id, name: id + '.txt', size: 1536, status: 'uploaded', available: false, chunk_count: 0, error: null };
+}
+let sourceFiles: Record<string, CloudAttachment[]>;
+const imported = vi.fn<(file: CloudKnowledgeFile) => Promise<void>>();
+const pending = vi.fn();
+const close = vi.fn();
+const props = { slug, kbId: 'kb_own', kbName: '我的观察记录', busy: false, act: async (task: () => Promise<void>) => task(), onImported: imported, onPendingChange: pending, onClose: close };
+
+beforeEach(() => {
+  vi.resetAllMocks(); imported.mockResolvedValue();
+  sourceFiles = { spring: [attachment('a', '观察报告.md'), attachment('b', '植物资料.pdf')], reading: [attachment('a', '阅读笔记.txt')] };
+  api.list.mockResolvedValue({ agents: [{ slug, name: '资料小助手' }], next_cursor: null });
+  api.call.mockImplementation(async (operation: string, input: { thread_id?: string; attachment_id?: string }) => {
+    if (operation === 'threads') return { threads, next_offset: null };
+    if (operation === 'received') return { agents: [{ slug: otherSlug, name: '阅读搭档' }] };
+    if (operation === 'attachments') return { attachments: sourceFiles[input.thread_id!] };
+    if (operation === 'importKnowledgeAttachment') return knowledgeFile(input.attachment_id!);
+    throw new Error('Unexpected operation ' + operation);
+  });
+});
+afterEach(cleanup);
+async function chooseChat(title = threads[0].title) {
+  fireEvent.click(await screen.findByRole('button', { name: '选择对话 ' + title }));
+}
+async function chooseFile(name: string) { fireEvent.click(await screen.findByRole('checkbox', { name: '选择文件 ' + name })); }
+function imports() { return api.call.mock.calls.filter(([operation]) => operation === 'importKnowledgeAttachment').map(([, input]) => input); }
+function deferred<T>() {
+  let resolve!: (value: T) => void;
+  let reject!: (error: Error) => void;
+  const promise = new Promise<T>((yes, no) => { resolve = yes; reject = no; });
+  return { promise, resolve, reject };
+}
+
+it('searches named and dated chats, keeps selections across chats, and imports only explicitly selected attachments', async () => {
+  const original = api.call.getMockImplementation()!;
+  api.call.mockImplementation((operation, input) => operation === 'threads'
+    ? Promise.resolve(input.offset ? { threads: [threads[1]], next_offset: null } : { threads: [threads[0]], next_offset: 50 }) : original(operation, input));
+  render(<CloudKnowledgeAttachmentPicker {...props} />);
+  expect(screen.getByRole('dialog', { name: '从聊天选择文件' })).toHaveTextContent('导入到「我的观察记录」');
+  await screen.findByText(/阅读搭档 · 2026/);
+  fireEvent.change(screen.getByRole('textbox', { name: '搜索对话' }), { target: { value: '资料小助手' } });
+  expect(screen.queryByRole('button', { name: '选择对话 图书阅读记录' })).not.toBeInTheDocument();
+  await chooseChat();
+  expect(await screen.findByText('MD · 2 KB')).toBeVisible();
+  fireEvent.change(screen.getByRole('textbox', { name: '搜索文件' }), { target: { value: '观察' } });
+  expect(screen.queryByRole('checkbox', { name: '选择文件 植物资料.pdf' })).not.toBeInTheDocument();
+  await chooseFile('观察报告.md');
+  fireEvent.change(screen.getByRole('textbox', { name: '搜索对话' }), { target: { value: '阅读' } });
+  await chooseChat(threads[1].title); await chooseFile('阅读笔记.txt');
+  expect(within(screen.getByRole('list', { name: '已选聊天文件' })).getAllByRole('listitem')).toHaveLength(2);
+  expect(imports()).toHaveLength(0);
+  fireEvent.click(screen.getByRole('button', { name: '导入 2 个文件' }));
+  await waitFor(() => expect(close).toHaveBeenCalledTimes(1));
+  expect(imports()).toEqual([
+    expect.objectContaining({ slug, kb_id: 'kb_own', thread_id: 'spring', attachment_id: 'a' }),
+    expect.objectContaining({ slug, kb_id: 'kb_own', thread_id: 'reading', attachment_id: 'a' }),
+  ]);
+  expect(new Set(imports().map(input => input.operation_id)).size).toBe(2);
+  expect(imported).toHaveBeenCalledTimes(2);
+  expect(api.call.mock.calls.some(([operation]) => ['history', 'files', 'deleteAttachment'].includes(operation))).toBe(false);
+  expect(pending).toHaveBeenLastCalledWith(false);
+});
+
+it('retries only failed files with their original identity, retaining successful files and processing callbacks', async () => {
+  const original = api.call.getMockImplementation()!;
+  let failure = true;
+  api.call.mockImplementation((operation, input) => operation === 'importKnowledgeAttachment' && input.attachment_id === 'b' && failure
+    ? Promise.reject(new Error('连接超时')) : original(operation, input));
+  render(<CloudKnowledgeAttachmentPicker {...props} />);
+  await chooseChat(); await chooseFile('观察报告.md'); await chooseFile('植物资料.pdf');
+  fireEvent.click(screen.getByRole('button', { name: '导入 2 个文件' }));
+  await screen.findByText(/导入结果尚未确认：连接超时/);
+  expect(close).not.toHaveBeenCalled(); expect(imported).toHaveBeenCalledTimes(1);
+  expect(screen.getByRole('button', { name: '关闭文件选择' })).toBeDisabled();
+  expect(screen.getByRole('button', { name: '选择对话 图书阅读记录' })).toBeDisabled();
+  fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+  expect(close).not.toHaveBeenCalled();
+  const first = imports();
+  failure = false;
+  fireEvent.click(screen.getByRole('button', { name: '重试失败的 1 个文件' }));
+  await waitFor(() => expect(close).toHaveBeenCalledTimes(1));
+  expect(imports()).toHaveLength(3); expect(imports()[2]).toEqual(first[1]);
+  expect(imported).toHaveBeenCalledTimes(2);
+});
+
+it('never reimports a confirmed file after a processing callback failure and permits a later independent batch', async () => {
+  imported.mockRejectedValueOnce(new Error('处理失败'));
+  render(<CloudKnowledgeAttachmentPicker {...props} />);
+  await chooseChat(); await chooseFile('观察报告.md');
+  fireEvent.click(screen.getByRole('button', { name: '导入 1 个文件' }));
+  await screen.findByText(/文件已导入，处理未全部启动/);
+  expect(imports()).toHaveLength(1); expect(close).not.toHaveBeenCalled();
+  expect(screen.getByRole('button', { name: '关闭文件选择' })).toBeEnabled();
+  await chooseFile('植物资料.pdf');
+  fireEvent.click(screen.getByRole('button', { name: '导入 1 个文件' }));
+  await waitFor(() => expect(close).toHaveBeenCalledTimes(1));
+  expect(imports().map(input => input.attachment_id)).toEqual(['a', 'b']);
+});
+
+it('shows file types and sizes, disables unsupported legacy formats and oversize files, and accepts supported files at the size boundary', async () => {
+  sourceFiles.spring = [attachment('legacy-doc', '旧文档.doc'), attachment('legacy-xls', '旧表格.xls'), attachment('markdown', '资料.markdown'),
+    attachment('image', '图片.png'), attachment('large', '过大的资料.pdf', 5 * 1024 * 1024 + 1), attachment('boundary', '可导入.DOCX', 5 * 1024 * 1024)];
+  render(<CloudKnowledgeAttachmentPicker {...props} />); await chooseChat();
+  for (const name of ['旧文档.doc', '旧表格.xls', '资料.markdown', '图片.png', '过大的资料.pdf']) expect(await screen.findByRole('checkbox', { name: '选择文件 ' + name })).toBeDisabled();
+  expect(screen.getAllByText('此格式暂不支持知识库导入')).toHaveLength(4);
+  expect(screen.getByText('超过 5 MB，暂不能导入')).toBeVisible();
+  expect(screen.getByText('DOCX · 5.0 MB')).toBeVisible();
+  await chooseFile('可导入.DOCX');
+  fireEvent.click(screen.getByRole('button', { name: '导入 1 个文件' }));
+  await waitFor(() => expect(close).toHaveBeenCalledOnce());
+  expect(imports()).toEqual([expect.objectContaining({ attachment_id: 'boundary' })]);
+});
+
+it('distinguishes loading, empty chats, chat read failures and a successful retry', async () => {
+  const loading = deferred<{ threads: CloudThread[]; next_offset: null }>();
+  const original = api.call.getMockImplementation()!;
+  let mode = 'loading';
+  api.call.mockImplementation((operation, input) => {
+    if (operation !== 'threads') return original(operation, input);
+    return mode === 'loading' ? loading.promise : mode === 'error' ? Promise.reject(new Error('目录离线')) : Promise.resolve({ threads, next_offset: null });
+  });
+  const view = render(<CloudKnowledgeAttachmentPicker {...props} />);
+  expect(screen.getByText('正在读取对话…')).toBeVisible();
+  expect(screen.queryByText('还没有个人智能体对话。')).not.toBeInTheDocument();
+  await act(async () => loading.resolve({ threads: [], next_offset: null }));
+  expect(screen.getByText('还没有个人智能体对话。')).toBeVisible();
+  view.unmount(); mode = 'error'; render(<CloudKnowledgeAttachmentPicker {...props} />);
+  await screen.findByText('对话读取失败：目录离线');
+  expect(screen.queryByText('还没有个人智能体对话。')).not.toBeInTheDocument();
+  mode = 'ready'; fireEvent.click(screen.getByRole('button', { name: '重试读取对话' }));
+  await screen.findByRole('button', { name: '选择对话 春天的观察讨论' });
+  expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+});
+
+it('distinguishes file loading, failures, empty files and search results while ignoring a late response from a previous chat', async () => {
+  const late = deferred<{ attachments: CloudAttachment[] }>();
+  const original = api.call.getMockImplementation()!;
+  let readingFails = true;
+  api.call.mockImplementation((operation, input) => operation === 'attachments'
+    ? input.thread_id === 'spring' ? late.promise : readingFails ? Promise.reject(new Error('文件离线')) : Promise.resolve({ attachments: [] })
+    : original(operation, input));
+  render(<CloudKnowledgeAttachmentPicker {...props} />); await chooseChat();
+  expect(screen.getByText('正在读取文件…')).toBeVisible();
+  expect(screen.queryByText('这段对话还没有上传文件。')).not.toBeInTheDocument();
+  await chooseChat(threads[1].title); await screen.findByText('文件读取失败：文件离线');
+  await act(async () => late.resolve({ attachments: sourceFiles.spring }));
+  expect(screen.queryByRole('checkbox')).not.toBeInTheDocument();
+  readingFails = false; fireEvent.click(screen.getByRole('button', { name: '重试读取文件' }));
+  await screen.findByText('这段对话还没有上传文件。');
+  expect(screen.queryByRole('alert')).not.toBeInTheDocument();
+  fireEvent.change(screen.getByRole('textbox', { name: '搜索对话' }), { target: { value: '不存在' } });
+  expect(screen.getByText('没有匹配的对话。')).toBeVisible();
+});
+
+it('guards X, escape and selection during an in-flight import, then closes only after all files finish', async () => {
+  const first = deferred<CloudKnowledgeFile>();
+  const original = api.call.getMockImplementation()!;
+  api.call.mockImplementation((operation, input) => operation === 'importKnowledgeAttachment' && input.attachment_id === 'a' ? first.promise : original(operation, input));
+  render(<CloudKnowledgeAttachmentPicker {...props} />); await chooseChat(); await chooseFile('观察报告.md'); await chooseFile('植物资料.pdf');
+  fireEvent.click(screen.getByRole('button', { name: '导入 2 个文件' }));
+  expect(imports()).toHaveLength(1);
+  expect(screen.getByRole('button', { name: '关闭文件选择' })).toBeDisabled();
+  expect(screen.getByRole('checkbox', { name: '选择文件 观察报告.md' })).toBeDisabled();
+  expect(screen.queryByRole('button', { name: '放弃重试', exact: true })).not.toBeInTheDocument();
+  fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+  expect(close).not.toHaveBeenCalled();
+  await act(async () => first.resolve(knowledgeFile('a')));
+  await waitFor(() => expect(close).toHaveBeenCalledOnce());
+  expect(imports()).toHaveLength(2); expect(imported).toHaveBeenCalledTimes(2);
+});
+
+it('does not read or import without management permission and resumes a confirmed receipt without importing it twice', async () => {
+  const receipt = deferred<CloudKnowledgeFile>();
+  const original = api.call.getMockImplementation()!;
+  api.call.mockImplementation((operation, input) => operation === 'importKnowledgeAttachment' ? receipt.promise : original(operation, input));
+  const view = render(<CloudKnowledgeAttachmentPicker {...props} canRead={false} />);
+  expect(api.call).not.toHaveBeenCalled(); expect(api.list).not.toHaveBeenCalled();
+  view.rerender(<CloudKnowledgeAttachmentPicker {...props} />); await chooseChat(); await chooseFile('观察报告.md');
+  fireEvent.click(screen.getByRole('button', { name: '导入 1 个文件' }));
+  view.rerender(<CloudKnowledgeAttachmentPicker {...props} canRead={false} />);
+  await act(async () => receipt.resolve(knowledgeFile('a')));
+  expect(imports()).toHaveLength(1); expect(imported).not.toHaveBeenCalled(); expect(close).not.toHaveBeenCalled();
+  expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  expect(pending).toHaveBeenLastCalledWith(true);
+  view.rerender(<CloudKnowledgeAttachmentPicker {...props} />);
+  fireEvent.click(screen.getByRole('button', { name: '继续导入 1 个文件' }));
+  await waitFor(() => expect(close).toHaveBeenCalledOnce());
+  expect(imports()).toHaveLength(1); expect(imported).toHaveBeenCalledOnce();
+});
+
+it('ignores an old-target response and stops the old batch after a knowledge-base scope change', async () => {
+  const response = deferred<CloudKnowledgeFile>();
+  const original = api.call.getMockImplementation()!;
+  api.call.mockImplementation((operation, input) => operation === 'importKnowledgeAttachment' ? response.promise : original(operation, input));
+  const view = render(<CloudKnowledgeAttachmentPicker {...props} />);
+  await chooseChat(); await chooseFile('观察报告.md'); await chooseFile('植物资料.pdf');
+  fireEvent.click(screen.getByRole('button', { name: '导入 2 个文件' }));
+  view.rerender(<CloudKnowledgeAttachmentPicker {...props} kbId="kb_other" kbName="其他资料" />);
+  await act(async () => response.resolve(knowledgeFile('a')));
+  expect(imports()).toHaveLength(1); expect(imported).not.toHaveBeenCalled(); expect(close).not.toHaveBeenCalled();
+  expect(screen.getByRole('dialog')).toHaveTextContent('导入到「其他资料」');
+  expect(screen.queryByRole('list', { name: '文件导入结果' })).not.toBeInTheDocument();
+});
+
+it('does not continue a batch or notify the old owner after unmount', async () => {
+  const response = deferred<CloudKnowledgeFile>();
+  const original = api.call.getMockImplementation()!;
+  api.call.mockImplementation((operation, input) => operation === 'importKnowledgeAttachment' ? response.promise : original(operation, input));
+  const view = render(<CloudKnowledgeAttachmentPicker {...props} />);
+  await chooseChat(); await chooseFile('观察报告.md'); await chooseFile('植物资料.pdf');
+  fireEvent.click(screen.getByRole('button', { name: '导入 2 个文件' })); view.unmount();
+  await act(async () => response.resolve(knowledgeFile('a')));
+  expect(imports()).toHaveLength(1); expect(imported).not.toHaveBeenCalled(); expect(close).not.toHaveBeenCalled();
+  expect(pending).toHaveBeenLastCalledWith(false);
+});
+
+it('hides the portal after a confirmed loss of ownership so the parent can discard pending requests without importing again', async () => {
+  const response = deferred<CloudKnowledgeFile>();
+  const original = api.call.getMockImplementation()!;
+  let owned = true;
+  api.call.mockImplementation((operation, input) => {
+    if (operation === 'knowledge') return Promise.resolve({ databases: owned ? [{ kb_id: 'kb_own', name: '我的观察记录' }] : [], models: [] });
+    if (operation === 'knowledgeFiles') return Promise.resolve({ files: [], next_offset: null });
+    if (operation === 'importKnowledgeAttachment') return response.promise;
+    return original(operation, input);
+  });
+  const created = vi.fn();
+  const view = render(<CloudKnowledgePanel slug={slug} onCreated={created} />);
+  await screen.findByRole('option', { name: '我的观察记录' });
+  fireEvent.change(screen.getByRole('combobox', { name: '管理的知识库' }), { target: { value: 'kb_own' } });
+  fireEvent.click(await screen.findByRole('button', { name: '从聊天选择文件' }));
+  await chooseChat(); await chooseFile('观察报告.md'); await chooseFile('植物资料.pdf');
+  fireEvent.click(screen.getByRole('button', { name: '导入 2 个文件' }));
+  owned = false;
+  view.rerender(<CloudKnowledgePanel slug={slug} onCreated={created} refreshToken={1} />);
+  await waitFor(() => expect(screen.queryByRole('dialog', { name: '从聊天选择文件' })).not.toBeInTheDocument());
+  await act(async () => response.resolve(knowledgeFile('a')));
+  const discard = await screen.findByRole('button', { name: '放弃未确认操作并重新选择' });
+  await waitFor(() => expect(discard).toBeEnabled());
+  expect(imports()).toHaveLength(1);
+  expect(api.call.mock.calls.some(([operation]) => operation === 'processKnowledge')).toBe(false);
+  fireEvent.click(discard);
+  expect(screen.queryByRole('button', { name: '放弃未确认操作并重新选择' })).not.toBeInTheDocument();
+  expect(screen.getByRole('combobox', { name: '管理的知识库' })).toHaveValue('');
+});
+
+it('allows cancelling unsubmitted selections and does not mutate knowledge merely by choosing files', async () => {
+  render(<CloudKnowledgeAttachmentPicker {...props} />); await chooseChat(); await chooseFile('观察报告.md');
+  expect(pending).toHaveBeenLastCalledWith(true);
+  fireEvent.click(screen.getByRole('button', { name: '关闭文件选择' }));
+  expect(close).toHaveBeenCalledOnce(); expect(imports()).toHaveLength(0); expect(imported).not.toHaveBeenCalled();
+});
+
+it.each(['button', 'escape'])('allows %s dismissal during a catalog failure before any import has been sent', async control => {
+  const view = render(<CloudKnowledgeAttachmentPicker {...props} />);
+  await chooseChat(); await chooseFile('观察报告.md');
+  view.rerender(<CloudKnowledgeAttachmentPicker {...props} busy />);
+  expect(screen.getByRole('button', { name: '关闭文件选择' })).toBeEnabled();
+  if (control === 'button') fireEvent.click(screen.getByRole('button', { name: '关闭文件选择' }));
+  else fireEvent.keyDown(screen.getByRole('dialog'), { key: 'Escape' });
+  await waitFor(() => expect(close).toHaveBeenCalledOnce());
+  expect(imports()).toHaveLength(0);
+});
+
+it('offers a read-only catalog refresh while an uncertain import is blocked, then retries only the original operation', async () => {
+  const original = api.call.getMockImplementation()!;
+  let fails = true;
+  api.call.mockImplementation((operation, input) => operation === 'importKnowledgeAttachment' && fails
+    ? Promise.reject(new Error('结果未确认')) : original(operation, input));
+  const refresh = vi.fn();
+  const view = render(<CloudKnowledgeAttachmentPicker {...props} onRefreshKnowledge={refresh} />);
+  await chooseChat(); await chooseFile('观察报告.md');
+  fireEvent.click(screen.getByRole('button', { name: '导入 1 个文件' }));
+  await screen.findByText(/导入结果尚未确认：结果未确认/);
+  const request = imports()[0];
+  view.rerender(<CloudKnowledgeAttachmentPicker {...props} busy onRefreshKnowledge={refresh} />);
+  expect(screen.getByRole('button', { name: '关闭文件选择' })).toBeDisabled();
+  expect(screen.getByRole('button', { name: '重试失败的 1 个文件' })).toBeDisabled();
+  fireEvent.click(screen.getByRole('button', { name: '刷新知识库', exact: true }));
+  expect(refresh).toHaveBeenCalledOnce(); expect(imports()).toHaveLength(1);
+  fails = false;
+  view.rerender(<CloudKnowledgeAttachmentPicker {...props} onRefreshKnowledge={refresh} />);
+  fireEvent.click(screen.getByRole('button', { name: '重试失败的 1 个文件' }));
+  await waitFor(() => expect(close).toHaveBeenCalledOnce());
+  expect(imports()).toEqual([request, request]); expect(imported).toHaveBeenCalledOnce();
+});
+
+it('requires explicit confirmation to abandon a retry during a catalog failure, while keeping the request through cancelling that confirmation', async () => {
+  const original = api.call.getMockImplementation()!;
+  api.call.mockImplementation((operation, input) => operation === 'importKnowledgeAttachment'
+    ? Promise.reject(new Error('附件已无法读取')) : original(operation, input));
+  const view = render(<CloudKnowledgeAttachmentPicker {...props} />);
+  await chooseChat(); await chooseFile('观察报告.md');
+  fireEvent.click(screen.getByRole('button', { name: '导入 1 个文件' }));
+  await screen.findByText(/导入结果尚未确认：附件已无法读取/);
+  view.rerender(<CloudKnowledgeAttachmentPicker {...props} busy />);
+  fireEvent.click(screen.getByRole('button', { name: '放弃重试', exact: true }));
+  expect(screen.getByText('这只会结束当前页面的重试。已保存的文件会保留，可刷新知识库确认。')).toBeVisible();
+  expect(close).not.toHaveBeenCalled(); expect(pending).toHaveBeenLastCalledWith(true);
+  fireEvent.click(screen.getByRole('button', { name: '继续保留' }));
+  expect(screen.getByRole('button', { name: '重试失败的 1 个文件' })).toBeDisabled();
+  expect(screen.getByRole('list', { name: '文件导入结果' })).toHaveTextContent('观察报告.md');
+  fireEvent.click(screen.getByRole('button', { name: '放弃重试', exact: true }));
+  fireEvent.click(screen.getByRole('button', { name: '确认放弃重试' }));
+  expect(close).toHaveBeenCalledOnce(); expect(pending).toHaveBeenLastCalledWith(false);
+  expect(imports()).toHaveLength(1); expect(imported).not.toHaveBeenCalled();
+  expect(screen.queryByRole('list', { name: '文件导入结果' })).not.toBeInTheDocument();
+  expect(screen.queryByRole('list', { name: '已选聊天文件' })).not.toBeInTheDocument();
+});
+
+it('exits a partly successful batch with a permanent source error without deleting or replaying successful imports', async () => {
+  const original = api.call.getMockImplementation()!;
+  api.call.mockImplementation((operation, input) => operation === 'importKnowledgeAttachment' && input.attachment_id === 'b'
+    ? Promise.reject(new Error('原附件已经删除')) : original(operation, input));
+  render(<CloudKnowledgeAttachmentPicker {...props} />);
+  await chooseChat(); await chooseFile('观察报告.md'); await chooseFile('植物资料.pdf');
+  fireEvent.click(screen.getByRole('button', { name: '导入 2 个文件' }));
+  await screen.findByText(/导入结果尚未确认：原附件已经删除/);
+  expect(imported).toHaveBeenCalledOnce();
+  expect(screen.getByRole('button', { name: '关闭文件选择' })).toBeDisabled();
+  expect(screen.queryByText(/可继续切换对话选择/)).not.toBeInTheDocument();
+  const before = api.call.mock.calls.length;
+  fireEvent.click(screen.getByRole('button', { name: '放弃重试', exact: true }));
+  fireEvent.click(screen.getByRole('button', { name: '确认放弃重试' }));
+  expect(close).toHaveBeenCalledOnce(); expect(pending).toHaveBeenLastCalledWith(false);
+  expect(imported).toHaveBeenCalledOnce(); expect(imports()).toHaveLength(2);
+  expect(api.call).toHaveBeenCalledTimes(before);
+});
diff --git a/tests/unit/cloud-knowledge-picker.test.tsx b/tests/unit/cloud-knowledge-picker.test.tsx
index 66b880a7..e83b2689 100644
--- a/tests/unit/cloud-knowledge-picker.test.tsx
+++ b/tests/unit/cloud-knowledge-picker.test.tsx
@@ -63,7 +63,7 @@ it('never offers shared libraries to document management or mounts their mutatin
   await screen.findByText('MakeLore知识 · 只读'); openUpload();
   const manager = screen.getByRole('combobox', { name: '管理的知识库' });
   expect(within(manager).queryByRole('option', { name: '创作指南' })).not.toBeInTheDocument();
-  expect(screen.queryByRole('button', { name: '上传文档', exact: true })).not.toBeInTheDocument();
+  expect(screen.queryByRole('button', { name: '从电脑上传', exact: true })).not.toBeInTheDocument();
   expect(screen.queryByRole('button', { name: '删除知识库', exact: true })).not.toBeInTheDocument();
   expect(api.call.mock.calls.every(([operation]) => operation !== 'knowledgeFiles')).toBe(true);
 });
@@ -78,7 +78,7 @@ it('allows readable binding after an owned-list failure while withholding docume
   expect(screen.queryByRole('group', { name: 'MakeLore知识' })).not.toBeInTheDocument();
   choose('shared'); openUpload();
   expect(screen.getByRole('combobox', { name: '管理的知识库' })).toBeDisabled();
-  expect(screen.queryByRole('button', { name: '上传文档', exact: true })).not.toBeInTheDocument();
+  expect(screen.queryByRole('button', { name: '从电脑上传', exact: true })).not.toBeInTheDocument();
   failed = false;
   fireEvent.click(screen.getByRole('button', { name: '刷新知识库', exact: true }));
   await screen.findByText('MakeLore知识 · 只读');
@@ -116,9 +116,9 @@ it('selects an existing owned library for uploads and cancelling a file picker d
   await openOwn();
   expect(changes).toHaveBeenLastCalledWith(expect.objectContaining({ knowledges: ['shared', own.kb_id] }));
   api.uploadKnowledge.mockResolvedValue(null);
-  fireEvent.click(screen.getByRole('button', { name: '上传文档', exact: true }));
+  fireEvent.click(screen.getByRole('button', { name: '从电脑上传', exact: true }));
   await waitFor(() => expect(api.uploadKnowledge).toHaveBeenCalledTimes(1));
-  await waitFor(() => expect(screen.getByRole('button', { name: '上传文档', exact: true })).toBeEnabled());
+  await waitFor(() => expect(screen.getByRole('button', { name: '从电脑上传', exact: true })).toBeEnabled());
   expect(api.call.mock.calls.every(([operation]) => operation !== 'processKnowledge')).toBe(true);
   expect(screen.getByRole('button', { name: '移除知识库 创作指南' })).toBeVisible();
 });
@@ -180,7 +180,7 @@ it('keeps an uncertain upload scoped to its library through retry cancellation a
   const pending: Record<string, boolean> = {};
   render(<CloudPendingContext.Provider value={(id, value) => { pending[id] = value; }}><Harness initial={['shared']} /></CloudPendingContext.Provider>);
   await openOwn();
-  fireEvent.click(screen.getByRole('button', { name: '上传文档', exact: true }));
+  fireEvent.click(screen.getByRole('button', { name: '从电脑上传', exact: true }));
   await screen.findByText('上传结果未确认');
   expect(Object.values(pending).some(Boolean)).toBe(true);
   const manager = screen.getByRole('combobox', { name: '管理的知识库' });
@@ -224,7 +224,7 @@ it('preserves uncertain processing while refreshing and releases it when the ser
 it('retains unconfirmed operations in a disabled manager if its owned library disappears and requires explicit discard', async () => {
   api.uploadKnowledge.mockRejectedValue(new Error('上传结果未确认'));
   render(<Harness initial={['shared']} />); await openOwn();
-  fireEvent.click(screen.getByRole('button', { name: '上传文档', exact: true }));
+  fireEvent.click(screen.getByRole('button', { name: '从电脑上传', exact: true }));
   await screen.findByText('上传结果未确认');
   const before = api.call.mock.calls.filter(([operation]) => operation === 'knowledgeFiles').length;
   databases = []; fireEvent.click(screen.getByRole('button', { name: '刷新知识库与模型' }));
@@ -249,7 +249,7 @@ it('automatically processes a confirmed upload that finishes while both knowledg
   });
   api.uploadKnowledge.mockImplementation(() => new Promise(value => { finishUpload = value; }));
   render(<Harness />); await openOwn();
-  fireEvent.click(screen.getByRole('button', { name: '上传文档', exact: true }));
+  fireEvent.click(screen.getByRole('button', { name: '从电脑上传', exact: true }));
   holdRefresh = true; fireEvent.click(screen.getByRole('button', { name: '刷新目录' }));
   await screen.findByRole('option', { name: '正在读取我的知识库…' });
   await act(async () => finishUpload({ file_id: 'confirmed', name: '资料.txt', size: 10, status: 'uploaded', chunk_count: 0, available: false, error: null }));
@@ -270,7 +270,7 @@ it('finishes an authorized upload through a failed ownership refresh and does no
   });
   api.uploadKnowledge.mockImplementation(() => new Promise(value => { finishUpload = value; }));
   render(<Harness />); await openOwn();
-  fireEvent.click(screen.getByRole('button', { name: '上传文档', exact: true }));
+  fireEvent.click(screen.getByRole('button', { name: '从电脑上传', exact: true }));
   holdRefresh = true; fireEvent.click(screen.getByRole('button', { name: '刷新知识库', exact: true }));
   await screen.findByRole('option', { name: '正在读取我的知识库…' });
   await act(async () => rejectRefresh(new Error('目录连接失败')));
@@ -316,6 +316,6 @@ it('keeps an owned but unusable library manageable without adding an invalid bin
   await screen.findByText('上传第一份文档，让智能体用你的资料回答。');
   expect(screen.getByText('这个知识库当前暂不可选用。你仍可管理自己的文件，刷新目录后再试。')).toBeVisible();
   expect(changes).toHaveBeenCalledTimes(before);
-  expect(screen.getByRole('button', { name: '上传文档', exact: true })).toBeEnabled();
+  expect(screen.getByRole('button', { name: '从电脑上传', exact: true })).toBeEnabled();
   expect(changes.mock.calls.at(-1)?.[0].knowledges).toEqual(['shared']);
 });
diff --git a/tests/unit/cloud-knowledge-status.test.tsx b/tests/unit/cloud-knowledge-status.test.tsx
index e6814b60..2b029716 100644
--- a/tests/unit/cloud-knowledge-status.test.tsx
+++ b/tests/unit/cloud-knowledge-status.test.tsx
@@ -3,13 +3,15 @@ import { afterEach, beforeEach, expect, it, vi } from 'vitest';
 import { CloudKnowledgePanel } from '@/pages/CloudAgents/CloudKnowledge';
 import type { CloudKnowledgeFile } from '../../shared/cloud-agents';
 
-const api = vi.hoisted(() => ({ call: vi.fn(), uploadKnowledge: vi.fn() }));
+const api = vi.hoisted(() => ({ call: vi.fn(), uploadKnowledge: vi.fn(), list: vi.fn() }));
 vi.mock('@/lib/cloud-agents-api', () => ({ cloudAgentsApi: api }));
 const file: CloudKnowledgeFile = { file_id: 'file', name: '学习路线图.pdf', size: 3000, status: 'uploaded', chunk_count: 0, error: null, available: false };
 let items: CloudKnowledgeFile[];
 beforeEach(() => {
   vi.resetAllMocks(); items = [];
+  api.list.mockResolvedValue({ agents: [], next_cursor: null });
   api.call.mockImplementation(async operation => {
+    if (operation === 'received') return { agents: [] };
     if (operation === 'knowledge') return { databases: [{ kb_id: 'kb', name: '资料' }, { kb_id: 'other', name: '其他库' }], models: [] };
     if (operation === 'knowledgeFiles') return { files: items, next_offset: null };
     if (operation === 'processKnowledge') {
@@ -33,7 +35,7 @@ it('uploads then processes automatically and refreshes through queue, parse, ind
   await screen.findByText('上传第一份文档，让智能体用你的资料回答。');
   vi.useFakeTimers();
   api.uploadKnowledge.mockImplementation(async () => { items = [file]; return file; });
-  await act(async () => { fireEvent.click(screen.getByRole('button', { name: '上传文档', exact: true })); });
+  await act(async () => { fireEvent.click(screen.getByRole('button', { name: '从电脑上传', exact: true })); });
   expect(screen.getByText('等待处理')).toBeVisible();
   expect(screen.queryByText(/0 个分块/)).not.toBeInTheDocument();
   expect(api.call).toHaveBeenCalledWith('processKnowledge', expect.objectContaining({ kb_id: 'kb', file_id: 'file' }));
@@ -74,7 +76,7 @@ it('retains the saved upload and processing identity after an uncertain submissi
   });
   api.uploadKnowledge.mockImplementation(async () => { items = [file]; return file; });
   await open();
-  fireEvent.click(screen.getByRole('button', { name: '上传文档', exact: true }));
+  fireEvent.click(screen.getByRole('button', { name: '从电脑上传', exact: true }));
   expect(await screen.findByRole('alert')).toHaveTextContent('文件已保存，处理请求尚未确认');
   expect(screen.getByRole('article', { name: file.name })).toBeVisible();
   fireEvent.click(screen.getByRole('button', { name: '重试处理' }));
@@ -169,12 +171,10 @@ it('imports an attachment and processes it without claiming immediate readiness'
     return original(operation, input);
   });
   await open();
-  fireEvent.click(screen.getByRole('button', { name: '从对话附件导入' }));
-  await screen.findByRole('option', { name: '我的对话' });
-  fireEvent.change(screen.getByLabelText('附件来源对话'), { target: { value: 'thread' } });
-  await screen.findByRole('option', { name: '附件.pdf' });
-  fireEvent.change(screen.getByLabelText('入库附件'), { target: { value: 'attachment' } });
-  fireEvent.click(screen.getByRole('button', { name: '确认导入知识库' }));
+  fireEvent.click(screen.getByRole('button', { name: '从聊天选择文件' }));
+  fireEvent.click(await screen.findByRole('button', { name: '选择对话 我的对话' }));
+  fireEvent.click(await screen.findByRole('checkbox', { name: '选择文件 附件.pdf' }));
+  fireEvent.click(screen.getByRole('button', { name: '导入 1 个文件' }));
   await screen.findByText('等待处理');
   expect(screen.queryByText('可用于回答')).not.toBeInTheDocument();
 });