diff --git a/.project-docs/10-decisions/adr-001-ai-design-conversation-ownership.md b/.project-docs/10-decisions/adr-001-ai-design-conversation-ownership.md
new file mode 100644
index 0000000..27761b9
--- /dev/null
+++ b/.project-docs/10-decisions/adr-001-ai-design-conversation-ownership.md
@@ -0,0 +1,43 @@
+# ADR-001: AI 绘画 Workspace / Conversation 状态归属
+
+## Status
+
+Accepted
+
+## Date
+
+2026-08-11
+
+## Context
+
+旧客户端把一个 AI 绘画 Workspace 等同于一条持续对话，并由客户端按 Workspace 创建和回收临时 Agent Session。多会话产品模型要求同一设计项目内存在多条独立对话，同时保留项目级生成任务与资产。继续沿用旧 Session 所有权会让注销时的远端 DELETE 破坏 Conversation 的持久上下文。
+
+## Decision
+
+- Workspace 持有项目身份、Conversation 列表、生成任务和资产。
+- Conversation 持有消息、Brief、Quote、`turnRevision` 以及服务端持久 Agent Gateway Session 的绑定。
+- 新建 Conversation 不创建新 Workspace；切换 Conversation 只读取该对话并重连其事件流，项目级任务和资产保持可见。
+- Conversation 异步与流式更新必须同时校验 Workspace + Conversation 身份；Task 更新按 Workspace 归并。
+- 客户端不创建、旋转或在注销/退出时 DELETE 服务端持久 Conversation Session。终端清理只关闭本地流、清除本机 Session-id 缓存和本地凭据；后续访问重新从 Conversation API 读取 Session。
+- 未打包的本地开发适配器把旧单会话 schema v2 迁移为带默认 Conversation 的 schema v3；该适配器不得成为打包应用的云端失败回退。
+
+## Rationale
+
+该分层与用户可见的“一个设计项目，多条独立会话，共享生成结果”一致，并让 Session 生命周期由持久化 Conversation 的服务端权威管理。Workspace + Conversation 双重身份和 generation/revision 防护可以阻止切换过程中的迟到异步结果污染当前对话。
+
+## Consequences
+
+- 客户端发布前必须先部署服务端迁移 `0033` 与多 Conversation API。
+- 退出登录不会删除远端 Conversation Session；服务端继续通过认证与授权控制访问。
+- Renderer、Host API、云端适配器和本地开发适配器都必须保持相同的 Workspace / Conversation / Task 所有权语义。
+- Conversation 数量增长后可能需要分页和搜索；当前侧栏只内联展示近期会话。
+
+## Supersedes
+
+- 旧的未文档化“每个 Workspace 由客户端创建并在注销时删除临时事件 Session”实现。
+
+## Related
+
+- `498089401708dc08123141891dba9b54e47cefea`
+- `03dae62cf35d643bba253d1013579cc3f4f528e4`
+- `.project-docs/30-worklog/tasks/20260806-design-multisession-ui-4e7d.md`
diff --git a/.project-docs/10-decisions/decision-index.md b/.project-docs/10-decisions/decision-index.md
index a30eae1..c84f5fa 100644
--- a/.project-docs/10-decisions/decision-index.md
+++ b/.project-docs/10-decisions/decision-index.md
@@ -4,6 +4,7 @@
 
 | ID | Decision | Status | Date | Applies To | Detail |
 |---|---|---|---|---|---|
+| ADR-001 | AI 绘画采用 Workspace / Conversation / Task 分层状态与服务端持久 Conversation Session | Accepted | 2026-08-11 | AI 绘画客户端、Main 适配器、Works Square API | `adr-001-ai-design-conversation-ownership.md` |
 
 ## Superseded Decisions
 
diff --git a/.project-docs/20-architecture/data-flow.md b/.project-docs/20-architecture/data-flow.md
index b561745..3f093d9 100644
--- a/.project-docs/20-architecture/data-flow.md
+++ b/.project-docs/20-architecture/data-flow.md
@@ -10,6 +10,9 @@
 | 提交绑定 | 云端成功上传响应 | Main → submission binding v2 | 只持久化成功的 app/version/review/hash；落盘失败返回固定告警但不反转提交 |
 | 运营发布 | Works Square 审核与交付 | 公共 `play_url` | 客户端只消费服务端发布结果；真实 Builder → OSS/CDN 生产链仍待整链验收 |
 | 真机预览 | 项目空间 | Main → Owner preview / `play_url` | 核对 app、version、release 和同源 HTTPS；`runtime_url` 仅一版本兼容回退 |
+| 设计会话创建/切换 | AI 绘画页面或侧栏 | Renderer API → Main → Workspace Conversation API | 新会话属于现有 Workspace；读取独立消息、Brief、Quote 和 `turnRevision` |
+| 设计消息与确认 | 当前 Conversation | Main → 持久 Agent Gateway Session → Conversation 快照 | 请求和流式结果同时绑定 Workspace + Conversation |
+| 设计任务同步 | 任一 Conversation 的事件流 / REST | Renderer Workspace 任务列表 | Task 和 Asset 按 Workspace 归并，切换 Conversation 后仍可见 |
 
 ## State Ownership
 
@@ -17,13 +20,17 @@
 - 项目内 `.niancode/project.json` 保存 `ProjectType`；Main 在配置写入和目录复用时保持其不可变，并在打包时重新读取校验。
 - Renderer 仅持有短效公开会话状态、提交展示状态和安全投影后的公共播放/短时预览 URL。
 - 旧 schema v1 `submitted` 记录迁移并保留；旧 `armed`、`waiting_for_package`、`waiting_for_login`、`uploading`、`failed` 归一为 `legacy_retired`，不再启动 watcher 或上传任务。
+- AI 绘画 Conversation 持有消息、Brief、Quote、`turnRevision` 和服务端 Session 绑定；Workspace 持有 Conversation 列表、生成任务和资产。
+- 本地开发适配器将旧单会话 schema v2 原子迁移为带默认 Conversation 的 schema v3；打包应用不使用该本地适配器作为云端失败回退。
+- 注销和退出会关闭本地事件流并清除本机 Conversation Session-id 缓存；服务端持久 Session 保留，下一次访问从 Conversation API 重新读取。
 
 ## External Interfaces
 
 - Works Square 项目创建、版本上传、构建状态、Owner 状态与 Release preview API。
 - 本机 Host API 的发布与真机预览路由；发布路由要求 Renderer capability。
 - 服务端安全投影后的公共 `play_url`；只接受同源 HTTPS、精确 App 路径和可信版本状态。
+- Works Square Workspace/Conversation API、每个 Conversation 的 Agent Gateway Session 与单次 WebSocket ticket。
 
 ## Last Updated
 
-2026-08-10
+2026-08-11
diff --git a/.project-docs/20-architecture/module-map.md b/.project-docs/20-architecture/module-map.md
index ab9aab9..6778282 100644
--- a/.project-docs/20-architecture/module-map.md
+++ b/.project-docs/20-architecture/module-map.md
@@ -11,6 +11,13 @@
 | `electron/services/works-submission-binding.ts` | submission binding v2 持久化与旧 schema 迁移 | 旧中间态终止为 `legacy_retired`；文件名暂作安装兼容 |
 | `electron/api/works-play-url.ts` | 公共播放与 Owner preview URL 的共享安全校验 | 公共 `play_url` 必须同源 HTTPS 且精确匹配 App 路径 |
 | `electron/api/routes/device-preview.ts` | 精确提交版本的待审/已发布真机预览解析 | 待审使用短时 Release preview，已发布优先 `play_url` |
+| `shared/image-workspace.ts` | AI 绘画 Workspace、Conversation、Task、Asset 与事件共享契约 | Conversation 状态与 Workspace 任务归属必须分离 |
+| `electron/api/routes/image-workspace.ts` | AI 绘画 Host API 与本地事件流投影 | Renderer 只通过该路由访问 Main-owned workspace adapter |
+| `electron/image-workspace/works-square-workspace.ts` | Works Square 多 Conversation 云端适配器与 Gateway 事件映射 | 使用服务端持久 Session；本地清理不 DELETE 远端 Session |
+| `electron/image-workspace/local-workspace.ts` | 未打包开发模式的本地 Workspace 适配器和 v2→v3 迁移 | 仅开发使用，不得成为打包回退 |
+| `src/stores/image-workspace.ts` | 当前 Workspace/Conversation、项目任务及流式更新状态 | 异步结果按 Workspace + Conversation generation/revision 防护 |
+| `src/pages/ImageCanvas/index.tsx` | Conversation 对话、Quote 确认、统一任务列表与新会话入口 | Enter 发送、Shift+Enter 换行、IME 保护 |
+| `src/components/layout/ImageWorkspaceSidebar.tsx` | Workspace 与近期 Conversation 切换/创建 | 切换会话不清空项目级任务 |
 
 ## Dependency Direction
 
@@ -22,7 +29,9 @@
 - `electron/api/routes/works.ts` 同时承担发布 capability、上游安全投影和错误脱敏，变更时必须验证未在拒绝前读取凭据或项目文件。
 - `works-cloud-deploy.json` 是兼容文件名；不得因名称重新引入自动部署协调语义。
 - `runtime_url` 是一个客户端版本的迁移回退；删除前必须确认服务端和存量数据稳定提供 `play_url`。
+- 多 Conversation 事件处理必须区分对话快照与 Workspace 任务更新；不得用任务时间戳推进 Conversation 流水位，也不得让旧会话的迟到流覆盖当前会话。
+- `closeEventSessions` 只负责本地流和缓存生命周期；远端 Conversation Session 是服务端持久资源。
 
 ## Last Updated
 
-2026-08-10
+2026-08-11
diff --git a/.project-docs/20-architecture/system-overview.md b/.project-docs/20-architecture/system-overview.md
index 66167f6..208b8ea 100644
--- a/.project-docs/20-architecture/system-overview.md
+++ b/.project-docs/20-architecture/system-overview.md
@@ -16,6 +16,9 @@ Makelore 是 Electron 桌面客户端。Renderer 负责项目操作与状态展
 | Submission Binding | 保存云端已接受的精确 app/version/review/hash 绑定 | schema v2 只记录成功提交；旧中间态迁移为 `legacy_retired`，不恢复后台任务 |
 | Play URL Projection | 校验服务端公共播放地址 | 只接受同源 HTTPS 和精确 `/apps/{app_id}/`；优先 `play_url`，`runtime_url` 仅一版本回退 |
 | Device Preview | 核对本地绑定、远端版本和 Release | 待审使用短时 Owner preview；已发布使用安全投影后的 `play_url` |
+| AI Design Workspace | 保存项目身份、Conversation 列表、生成任务和资产 | 任务和资产在切换 Conversation 后继续可见 |
+| AI Design Conversation | 保存消息、Brief、Quote、`turnRevision` 与服务端 Agent Session 绑定 | 同一 Workspace 内互相隔离；Session 由服务端持久化 |
+| AI Design Event Routing | Main 云端适配器 → Host API/SSE → Renderer store | Conversation 更新按 Workspace + Conversation 路由；任务更新按 Workspace 归并 |
 
 ## Important Boundaries
 
@@ -27,11 +30,14 @@ Makelore 是 Electron 桌面客户端。Renderer 负责项目操作与状态展
 - 公共播放投影只有在上游 `playable === true`、版本名非空且 URL 通过同源 HTTPS、无 userinfo/loopback、长度、精确路径和无 query/fragment 校验时才可播放；不可信数据 fail closed。
 - Renderer 只能获得安全状态字段和可展示的播放/短时预览 URL，不得持有发布凭据、归档路径或自动部署状态。
 - 落盘文件名 `works-cloud-deploy.json` 仅为已安装客户端的数据兼容；领域模型和代码接口是 submission binding，不表示仍存在 cloud deployment coordinator。
+- AI 绘画中，一个 Workspace 可包含多条 Conversation；消息、Brief、Quote 和 `turnRevision` 属于 Conversation，生成任务和资产属于 Workspace。新建 Conversation 不得隐式创建新 Workspace。
+- 每条 Conversation 复用服务端持久 Agent Gateway Session。客户端不得在注销或退出时 DELETE 该 Session；只关闭本地事件流并清除本机 Session-id 缓存，重新访问时从 Conversation API 刷新。
+- Renderer 的异步与流式状态必须同时校验 Workspace + Conversation 身份；项目任务事件只按 Workspace 归并，避免切换会话时丢失任务或接收迟到消息。
 
 ## Related Decisions
 
-- 当前长期边界记录于 README、集成任务 `20260807-integrate-login-client-a4f8`、源任务 `20260810-static-release-only-a91c` 及本次 Integration Gate；后续如改变唯一入口、凭据所有权或重新引入客户端部署协调器，应新增 ADR。
+- 当前长期边界记录于 README、ADR-001、集成任务 `20260807-integrate-login-client-a4f8`、源任务 `20260810-static-release-only-a91c` 及本次 Integration Gate；后续如改变唯一入口、凭据所有权、Conversation 状态归属或重新引入客户端部署协调器，应新增 ADR。
 
 ## Last Updated
 
-2026-08-10
+2026-08-11
diff --git a/.project-docs/30-worklog/current-state.md b/.project-docs/30-worklog/current-state.md
index 08392bf..e0a1a7f 100644
--- a/.project-docs/30-worklog/current-state.md
+++ b/.project-docs/30-worklog/current-state.md
@@ -9,17 +9,21 @@ This file is the integrated default-branch snapshot. Feature tasks record progre
 - `1a19ad9` / `f02e99e`：项目真机预览、待审 Release Owner preview 及集成提交。
 - `493b31c`：客户端三类 `ProjectType`、小游戏/小程序受控发布模板与自定义项目发布隔离。
 - `4df0477` / `8dd99c1`：客户端静态发布唯一链路、旧 Compose 协调链退役及安全边界补强。
+- `4980894` / `03dae62`：AI 绘画 Enter 发送及同一 Workspace 下的多 Conversation 客户端模型。
 
 ## Current Focus
 
 客户端面向非专业用户提供“创建小游戏或小程序 → 项目配置中一键提交 → Main 安全打包上传 → 轮询云端构建 → 运营审核”的唯一创建者链路，并以项目级真机预览完成待审版本扫码验收；自定义和缺少类型字段的旧项目不提供该入口。已发布作品优先使用安全投影后的 `play_url`，`runtime_url` 仅保留一个客户端版本的兼容回退。
 
+AI 绘画的一个 Workspace 可包含多条 Conversation。消息、Brief、Quote 和 `turnRevision` 随 Conversation 隔离；生成任务和资产保持 Workspace 级共享。每条 Conversation 使用服务端持久 Agent Gateway Session，切换会话只重连对应事件流。
+
 ## Recently Completed
 
 - 2026-08-08：合并登录续期、一键发布和真机预览；发布成功后保存精确 app/version/review 映射，Renderer 不接触 Token、ZIP 或本地路径。
 - 2026-08-08：补齐跨平台 Electron E2E fixture、Windows ZIP 预检和异常成功响应安全投影。
 - 2026-08-09：新建项目支持小游戏、小程序和自定义三类不可变产品类型；前两类生成固定 Vite 发布模板，自定义及缺少类型字段的旧项目不显示一键提交入口。
 - 2026-08-10：删除客户端旧 Compose deploy-check、watcher/arm/upload 协调和手工 ZIP 路由；submission binding v2 保留旧 `submitted` 绑定并把旧中间态归一为 `legacy_retired`，同时补齐 Renderer capability、`play_url` 安全投影和本机绑定失败告警。
+- 2026-08-11：AI 绘画支持在同一设计项目内创建和切换多条独立 Conversation；保留项目级任务/资产，并使用 Workspace + Conversation 身份保护异步与流式更新。退出时关闭本地流并清除本地 Session-id 缓存，不删除服务端持久 Conversation Session。
 
 ## In Progress
 
@@ -44,7 +48,9 @@ This file is the integrated default-branch snapshot. Feature tasks record progre
 - `works-cloud-deploy.json` 仅是已安装数据的兼容文件名，不代表客户端仍拥有自动部署协调器；旧中间态不得恢复为后台任务。
 - 刷新凭据、发布 Token、ZIP、幂等键和重试只能由 Electron Main 持有。
 - 本地 `projectType` 只决定产品分流和模板选择，不得作为授权依据或替代 Main/服务端的包体校验。
+- AI 绘画消息、Brief、Quote 和 `turnRevision` 必须按 Workspace + Conversation 隔离；任务事件仍按 Workspace 归并，迟到的异步结果不得污染已切换的会话。
+- 服务端持久 Conversation Session 不由客户端在注销或退出时删除；Main 只关闭本地流、清除本机缓存并撤销本地凭据。
 
 ## Last Updated
 
-2026-08-10
+2026-08-11
diff --git a/.project-docs/30-worklog/tasks/20260811-merge-all-code-a7c91e.md b/.project-docs/30-worklog/tasks/20260811-merge-all-code-a7c91e.md
new file mode 100644
index 0000000..a8bac7e
--- /dev/null
+++ b/.project-docs/30-worklog/tasks/20260811-merge-all-code-a7c91e.md
@@ -0,0 +1,67 @@
+# Task: Merge all completed code into main
+
+## Identity
+
+- Task ID: 20260811-merge-all-code-a7c91e
+- Mode: Integration
+- Branch: main
+- Worktree: D:\Datas\OthersProjects\makelore
+- Base commit: 70e0f4054cf88029e3f2f4848e3d17ee3be70b7f
+- Owner: codex
+- Status: Completed
+
+## Scope
+
+- Integrate every completed local branch whose commits are not already contained by `main`.
+- Merge `codex/20260806-design-multisession-ui-4e7d-design-multisession-ui`, which already contains the completed Enter-to-send commit from `codex/design-enter-send-b83f`.
+- Preserve all behavior already integrated on `main`, resolve overlapping image-workspace changes semantically, and avoid merging stale or already-contained branches a second time.
+- Promote the accepted multi-conversation client-state model into canonical project memory and verify the integrated result.
+
+## Intent And Constraints
+
+- Treat Git ancestry as the source of truth for merge scope: only two local branch tips are not contained by `main`, and the multi-session branch is a strict descendant of the Enter-to-send branch.
+- Preserve Main/Host API ownership boundaries, project-scoped generation tasks, Conversation-scoped messages and streams, and the existing release/login behavior already on `main`.
+- Do not resolve meaningful conflicts with blanket `ours`/`theirs`; combine both sides according to their domain ownership.
+- Use the exact pnpm version pinned by `packageManager` and run focused tests before repository-level verification.
+- Keep unrelated historical encoding damage and stale worktrees out of this integration.
+
+## Plan
+
+1. Inspect branch ancestry, overlapping paths, and merge-conflict semantics.
+2. Merge the multi-session branch once; resolve conflicts while preserving both feature and integrated-main behavior.
+3. Update task-scoped and canonical integration records.
+4. Run focused AI Design tests, typecheck, lint, production build, and the full unit suite.
+5. Obtain an independent read-only Sol review, finish drift checks, and commit the integration.
+
+## Outcome
+
+- Verified that `03dae62` is a descendant of `4980894`; merging the multi-session branch once integrates both completed branch tips without duplicating Enter-to-send.
+- Resolved the only two textual conflicts in the Works Square AI Design adapter and its focused test. Human confirmation selected the persistent Conversation Session model: logout and shutdown close local streams and clear the local Session-id cache without deleting the server-owned Session.
+- Integrated Conversation create/read/list routing, Conversation-scoped messages and streams, Workspace-scoped generation tasks, local schema v2-to-v3 migration, and the Canvas/sidebar create-and-switch interactions.
+- Added focused API, route, adapter, migration, store, page, and sidebar regressions plus an Electron E2E that creates and switches Conversations while preserving project tasks and isolating messages.
+- Updated README and canonical project memory, including ADR-001, architecture/data-flow/domain ownership, the production migration commitment, and stale production-verification state.
+- Kept the two source-task records read-only in source commit history instead of copying them into the integration tree, as required by the current project-doc ownership gate.
+
+## Verification
+
+- Branch ancestry: `03dae62` contains `4980894`; no other local branch tip contains commits absent from the integrated merge scope.
+- Focused AI Design regressions: 8 files / 116 tests passed.
+- `pnpm run typecheck`: passed.
+- Scoped ESLint over all changed TypeScript and TSX files: passed.
+- `pnpm run build:vite`: passed; Renderer, Main, and Preload production compilation completed.
+- New multi-conversation Electron E2E: 1 passed.
+- `pnpm test`: 140/142 files and 1506/1508 tests passed. One failure is the pre-existing missing `.opencode/agent` fixture; the OpenCode port-release test timed out only in the parallel full run and passed alone.
+- `pnpm run lint:check`: repository baseline remains red on the pre-existing `MainLayout.tsx` state-in-effect rule and unused `rerender` in `chat-command-dialogs.test.tsx`; changed-file ESLint is green.
+- `pnpm run test:e2e`: 11 passed / 11 failed. The new multi-conversation spec passes; stale legacy selectors and a missing provider test IPC handler account for the remaining existing suite failures.
+- `check_project_docs.py`, task-aware `check_doc_drift.py`, and `git diff --check`: passed.
+- Independent final read-only Sol review: PASS with no blocking findings.
+
+## Follow-ups
+
+- Deploy and verify server migration `0033`, persistent Conversation Session creation, and multi-conversation APIs before releasing this client behavior to production.
+- Repair the unrelated repository lint, missing youth-skill fixture, timing-sensitive OpenCode unit test, and stale legacy Electron E2E baseline in separate maintenance tasks.
+- Tighten the global `creatingConversation` guard with a request generation/token if concurrent Workspace switching during Conversation creation becomes observable; the current edge case can briefly re-enable duplicate creation but does not overwrite data.
+
+## Promotion Candidates
+
+- None recorded.
diff --git a/.project-docs/40-domain/business-rules.md b/.project-docs/40-domain/business-rules.md
index a6fd325..3b32c2b 100644
--- a/.project-docs/40-domain/business-rules.md
+++ b/.project-docs/40-domain/business-rules.md
@@ -15,12 +15,17 @@
 - 已发布作品优先读取 `play_url`，只有字段缺失时才使用一个客户端版本的 `runtime_url` 回退。公共播放 URL 必须是 Works Square 同源 HTTPS、无 userinfo/loopback、精确 `/apps/{encodeURIComponent(app_id)}/`、无 query/fragment，且上游明确 `playable === true` 并提供非空版本名；否则按不可播放处理。
 - `works-cloud-deploy.json` 仅是已安装客户端的数据兼容文件名，不表示客户端仍提供 cloud deployment coordinator。
 - Works Square 会话按真实键盘、鼠标或触摸活动滑动续期，连续 7 天未使用才要求重新授权。
+- 一个 AI 绘画 Workspace 可以包含多条独立 Conversation；新建 Conversation 不得创建新 Workspace。
+- Conversation 持有消息、Brief、Quote 和 `turnRevision`；生成任务和资产属于 Workspace，切换 Conversation 后必须继续可见。
+- 每条 Conversation 使用服务端持久 Agent Gateway Session。客户端注销或退出时只关闭本地流并清除本机 Session-id 缓存，不删除服务端 Session。
+- Conversation 异步与流式更新必须同时核对 Workspace 和 Conversation 身份；任务事件按 Workspace 归并。
 
 ## Open Questions
 
 - 生产整链需要真实账号、Builder、OSS immutable Release、CDN/Edge、运营审核、App 播放与监控环境完成最终验收；当前客户端验证不能替代该验收。
 - 在一个客户端兼容版本且服务端与存量数据稳定提供 `play_url` 后，移除 `runtime_url` 回退。
+- 多 Conversation 客户端发布前需确认服务端迁移 `0033`、Conversation API 与持久 Session 契约已经部署。
 
 ## Last Reviewed
 
-2026-08-10
+2026-08-11
diff --git a/.project-docs/40-domain/glossary.md b/.project-docs/40-domain/glossary.md
index fe60c37..5d53ae0 100644
--- a/.project-docs/40-domain/glossary.md
+++ b/.project-docs/40-domain/glossary.md
@@ -9,3 +9,6 @@
 | `legacy_retired` | 旧自动部署中间态迁移后的终止状态 | 不恢复 watcher、登录等待或自动上传；提示用户从项目配置重新提交 |
 | `play_url` | 服务端为已发布作品提供的公共播放地址 | 客户端优先使用并执行同源 HTTPS、精确 App 路径和版本状态校验 |
 | `runtime_url` | `play_url` 上线期间的旧公共播放字段 | 仅保留一个客户端版本的兼容回退，稳定迁移后删除 |
+| AI Design Workspace | 一个 AI 绘画设计项目 | 持有 Conversation 列表、生成任务和资产；不是单条对话 |
+| AI Design Conversation | Workspace 内一条独立设计对话 | 持有消息、Brief、Quote、`turnRevision` 和服务端持久 Agent Session 绑定 |
+| Persistent Conversation Session | 服务端为 Conversation 持久保存的 Agent Gateway Session | 客户端只重连事件流，不在注销或退出时 DELETE |
diff --git a/.project-docs/50-evidence/evidence-index.md b/.project-docs/50-evidence/evidence-index.md
index ecda99d..3543558 100644
--- a/.project-docs/50-evidence/evidence-index.md
+++ b/.project-docs/50-evidence/evidence-index.md
@@ -4,6 +4,7 @@ Use this index for searchable, traceable evidence records.
 
 | Date | Topic | Status | Source | Detail |
 |---|---|---|---|---|
+| 2026-08-11 | AI 设计多会话客户端集成 | 本地功能验证通过；仓库基线仍有既有失败 | `30-worklog/tasks/20260811-merge-all-code-a7c91e.md`、`4980894`、`03dae62` | 8 files / 116 focused tests、typecheck、changed-file ESLint、production build 与新增 Electron E2E 通过；生产 migration 0033/API 尚待验收，全量 lint/unit/E2E 的既有失败已单独记录 |
 | 2026-08-10 | 客户端静态发布唯一链路 | 本地验证通过 | `30-worklog/tasks/20260810-static-release-only-a91c.md`、`4df0477`、`8dd99c1` | 227 项聚焦回归、typecheck、Vite/Electron build、实际 Electron E2E 与 13 files / 21 tests 收集通过；不等同于真实生产部署验收 |
 
 ## When To Add Evidence
diff --git a/.project-docs/80-commitments/commitments.md b/.project-docs/80-commitments/commitments.md
index cf61dd0..05a75b8 100644
--- a/.project-docs/80-commitments/commitments.md
+++ b/.project-docs/80-commitments/commitments.md
@@ -6,6 +6,7 @@ Track future-facing memory: promised follow-ups, unfinished loops, timed checks,
 |---|---|---|---|---|---|
 | 2026-08-10 | 完成客户端提交到 App `play_url` 播放的真实生产整链验收 | 服务端 Builder、OSS immutable Release、CDN/Edge 与 App 消费链成组集成后 | 客户端/服务端集成 | Pending | 使用真实账号执行小游戏和小程序创建、提交、浏览器门禁、运营批准、CDN 发布、App 播放与监控核对 |
 | 2026-08-10 | 删除客户端 `runtime_url` 兼容回退 | 一个客户端兼容版本结束，且服务端与存量数据稳定提供 `play_url` | 客户端 | Pending | 删除类型字段、读取分支和对应回归测试 |
+| 2026-08-11 | 部署并验收 AI 绘画多 Conversation 服务端契约 | 发布包含多会话客户端之前 | 客户端/服务端集成 | Pending | 确认迁移 `0033`、Conversation list/create/read/turn/confirm API、持久 Agent Session 与事件字段已上线 |
 
 ## Use
 
diff --git a/.project-docs/90-maintenance/stale-items.md b/.project-docs/90-maintenance/stale-items.md
index 2b5eb39..92bd313 100644
--- a/.project-docs/90-maintenance/stale-items.md
+++ b/.project-docs/90-maintenance/stale-items.md
@@ -10,6 +10,7 @@ This is the integrated registry of stale or conflicting canonical memory. Update
 ## Missing Context
 
 - 尚未验证真实生产环境是否已部署 Builder → OSS immutable Release → CDN/Edge，也未完成运营审核到 App `play_url` 播放的真实整链证据；客户端本地与模拟上游验证不能替代该结论。
+- 尚未验证生产 Works Square 已部署迁移 `0033`、多 Conversation API 与对应持久 Agent Session 契约；合并客户端代码不等同于具备生产发布条件。
 
 ## Feature Task Routing
 
diff --git a/README.md b/README.md
index 0e42f1a..54e90a6 100644
--- a/README.md
+++ b/README.md
@@ -17,7 +17,7 @@ Makelore 是一个面向软件与视觉创作的 AI 桌面工作台。当前版
 - 共享开发浏览器：AI 编程右侧提供项目级浏览器，用户与 Agent 查看并调试同一实时页面、Console 和 Network，支持本地与公网开发地址。
 - 真机预览：AI 编程项目空间可读取当前静态 Release 状态；待审版本使用短时预览地址，已发布版本使用同源 HTTPS `play_url`，供手机直接测试触控、屏幕和移动网络环境。
 - 后端边界：Renderer 通过 Main 所有的 Host API 访问认证、模型、同步、更新、语音、图像与运行时能力。
-- AI 绘画：每个设计项目固定一个设计 Agent。Agent 先通过持续对话收敛 Brief，用户确认服务端 Quote 后才创建图片或视频任务；任务进度通过 Agent Gateway 实时推送并在统一列表中展示，断流时使用低频 REST 同步。生产环境使用 Works Square 云端 Workspace 契约，上游不可用时明确报错。
+- AI 绘画：每个设计项目固定一个设计 Agent，并可包含多条互相独立的设计会话。消息、Brief、Quote 和 `turnRevision` 属于 Conversation；图片/视频生成任务与资产属于 Workspace，切换或新建会话不会创建新项目，也不会隐藏项目任务。每条 Conversation 复用服务端持久 Agent Gateway Session，任务进度通过实时流推送并在统一列表中展示，断流时使用低频 REST 同步。生产环境使用 Works Square 云端 Workspace 契约，上游不可用时明确报错。
 - 视觉系统：单一浅色主题，品牌蓝 `#3A5578`、星火橙 `#F26A3D`、白色画布与低饱和蓝灰层级。
 - 品牌资产：生产 SVG、PNG、应用图标、托盘图标与安装器视觉位于 [`resources/brand/`](resources/brand/README.md) 和 `resources/icons/`。
 
@@ -83,7 +83,7 @@ Windows 打包脚本会先准备目标架构所需的 Python、uv 与 OpenCode 
 - Works Square 登录态按真实键盘、鼠标或触摸活动滑动续期；持续使用无需反复授权，连续 7 天未使用才清除会话并要求重新登录。刷新凭据只由 Electron Main 持有，并在系统提供受保护凭据存储时加密落盘；Renderer 仅保存短效公开会话状态（旧版升级迁移时仅暂存既有刷新凭据，Main 成功接管后立即删除）。
 - AI 编程发布只经过 Main-owned Host API：Renderer 仅提交本地项目标识和非敏感作品资料；Main 持有文件读取、安全打包、Works Token、版本生成、幂等重试和安全状态投影。
 - AI 编程项目配置以项目内 `.niancode/project.json` 为准；项目文件和会话保持本地。
-- AI 绘画 Renderer 只调用 Main-owned Host API；Main 负责 Works Square Token 刷新、可跨异常重启幂等复用的 Agent Session、单次 WebSocket ticket、断点续传与事件契约映射，并通过本机 Host API 的 SSE 投影同步任务状态；注销/退出时回收 Session，远端 Token 与 ticket 不进入 Renderer。
+- AI 绘画 Renderer 只调用 Main-owned Host API；Main 负责 Works Square Token 刷新、Conversation 所属的服务端持久 Agent Session、单次 WebSocket ticket、断点续传与事件契约映射，并通过本机 Host API 的 SSE 投影同步任务状态。切换会话只重连对应流；注销或退出时关闭本地流并清除本机 Session-id 缓存，不删除服务端持久 Conversation Session。远端 Token 与 ticket 不进入 Renderer。
 - AI 绘画使用独立的云端 Workspace 边界，不回退到 AI 编程项目数据，也不向 Renderer 暴露 Provider、模型、Prompt、存储 URI 或远端登录 Token。
 - AI 编程的 Agent 配置是项目所有的；稳定 id 用于保持会话兼容，显示名称可以修改。AI 绘画的设计 Agent 是固定产品能力，不作为用户可增删的项目实体。
 
diff --git a/electron/api/routes/image-workspace.ts b/electron/api/routes/image-workspace.ts
index 6dac961..1d76292 100644
--- a/electron/api/routes/image-workspace.ts
+++ b/electron/api/routes/image-workspace.ts
@@ -11,6 +11,7 @@ import {
   IMAGE_WORKSPACE_UNAVAILABLE_CODE,
   IMAGE_WORKSPACE_UNAVAILABLE_MESSAGE,
   type DesignAssetUploadInput,
+  type DesignCreateConversationInput,
   type DesignConfirmGenerationInput,
   type DesignCreateWorkspaceInput,
   type DesignRenameWorkspaceInput,
@@ -283,6 +284,7 @@ async function relayWorkspaceEvents(
   res: ServerResponse,
   ctx: HostApiContext,
   workspaceId: string,
+  conversationId: string,
 ): Promise<void> {
   if (!ctx.imageWorkspace?.openWorkspaceEvents) {
     throw new DesignWorkspaceModuleError(
@@ -295,6 +297,7 @@ async function relayWorkspaceEvents(
   const afterEventId = Array.isArray(header) ? header[0] : header;
   const subscription = await ctx.imageWorkspace.openWorkspaceEvents({
     workspaceId,
+    conversationId,
     ...(afterEventId ? { afterEventId } : {}),
   });
   let closed = false;
@@ -399,11 +402,35 @@ export async function handleImageWorkspaceRoutes(
 
     if (segments.length === 3
       && segments[0] === 'workspaces'
-      && segments[2] === 'messages'
+      && segments[2] === 'conversations'
+      && req.method === 'POST') {
+      const body = await parseJsonBody<Record<string, unknown>>(req);
+      const input: DesignCreateConversationInput = {
+        workspaceId: segments[1],
+        clientConversationId: asString(body.clientConversationId),
+        title: asString(body.title),
+      };
+      sendData(res, await ctx.imageWorkspace.createConversation(input));
+      return true;
+    }
+
+    if (segments.length === 4
+      && segments[0] === 'workspaces'
+      && segments[2] === 'conversations'
+      && req.method === 'GET') {
+      sendData(res, await ctx.imageWorkspace.getConversation(segments[1], segments[3]));
+      return true;
+    }
+
+    if (segments.length === 5
+      && segments[0] === 'workspaces'
+      && segments[2] === 'conversations'
+      && segments[4] === 'messages'
       && req.method === 'POST') {
       const body = await parseJsonBody<Record<string, unknown>>(req);
       const input: DesignSubmitMessageInput = {
         workspaceId: segments[1],
+        conversationId: segments[3],
         clientTurnId: asString(body.clientTurnId),
         expectedTurnRevision: asInteger(body.expectedTurnRevision),
         message: asString(body.message),
@@ -440,23 +467,26 @@ export async function handleImageWorkspaceRoutes(
       return true;
     }
 
-    if (segments.length === 3
+    if (segments.length === 5
       && segments[0] === 'workspaces'
-      && segments[2] === 'events'
+      && segments[2] === 'conversations'
+      && segments[4] === 'events'
       && req.method === 'GET') {
-      await relayWorkspaceEvents(req, res, ctx, segments[1]);
+      await relayWorkspaceEvents(req, res, ctx, segments[1], segments[3]);
       return true;
     }
 
-    if (segments.length === 5
+    if (segments.length === 7
       && segments[0] === 'workspaces'
-      && segments[2] === 'quotes'
-      && segments[4] === 'confirm'
+      && segments[2] === 'conversations'
+      && segments[4] === 'quotes'
+      && segments[6] === 'confirm'
       && req.method === 'POST') {
       const body = await parseJsonBody<Record<string, unknown>>(req);
       const input: DesignConfirmGenerationInput = {
         workspaceId: segments[1],
-        quoteId: segments[3],
+        conversationId: segments[3],
+        quoteId: segments[5],
         clientTurnId: asString(body.clientTurnId),
         expectedTurnRevision: asInteger(body.expectedTurnRevision),
       };
diff --git a/electron/image-workspace/local-workspace.ts b/electron/image-workspace/local-workspace.ts
index fa8dddb..410cca3 100644
--- a/electron/image-workspace/local-workspace.ts
+++ b/electron/image-workspace/local-workspace.ts
@@ -3,7 +3,10 @@ import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import type {
   DesignCapabilities,
+  DesignConversation,
+  DesignConversationSummary,
   DesignConfirmGenerationInput,
+  DesignCreateConversationInput,
   DesignCreateWorkspaceInput,
   DesignGenerationQuote,
   DesignGenerationTask,
@@ -12,13 +15,15 @@ import type {
   DesignSubmitMessageInput,
   DesignWorkspace,
   DesignWorkspaceBootstrap,
+  DesignWorkspaceSummary,
 } from '../../shared/image-workspace';
 import { designAssetContentPath } from '../../shared/image-workspace';
 import { DesignWorkspaceModuleError, type DesignWorkspaceModule } from './module';
 
-const LOCAL_WORKSPACE_SCHEMA_VERSION = 2;
+const LOCAL_WORKSPACE_SCHEMA_VERSION = 3;
 const LOCAL_WORKSPACE_DIRECTORY = 'image-workspace-development';
-const LOCAL_WORKSPACE_FILE = 'design-workspace-v2.json';
+const LOCAL_WORKSPACE_FILE = 'design-workspace-v3.json';
+const LEGACY_LOCAL_WORKSPACE_FILE = 'design-workspace-v2.json';
 const MAX_PROJECT_NAME_LENGTH = 80;
 const MAX_MESSAGE_LENGTH = 4_000;
 
@@ -29,8 +34,12 @@ const LOCAL_CAPABILITIES: DesignCapabilities = {
   video: true,
 };
 
-type PersistedWorkspace = DesignWorkspace & {
+type PersistedWorkspace = DesignWorkspaceSummary & {
   clientWorkspaceId: string;
+};
+
+type PersistedConversation = DesignConversation & {
+  clientConversationId: string;
   requestHashes: Record<string, string>;
 };
 
@@ -43,6 +52,27 @@ type PersistedAsset = {
 type PersistedImageWorkspace = {
   schemaVersion: typeof LOCAL_WORKSPACE_SCHEMA_VERSION;
   workspaces: PersistedWorkspace[];
+  conversationsByWorkspaceId: Record<string, PersistedConversation[]>;
+  tasksByWorkspaceId: Record<string, DesignGenerationTask[]>;
+  assetsById: Record<string, PersistedAsset>;
+};
+
+type LegacyPersistedWorkspace = {
+  workspaceId: string;
+  clientWorkspaceId: string;
+  title: string;
+  turnRevision: number;
+  viewRevision: number;
+  phase: DesignConversation['phase'];
+  brief: DesignConversation['brief'];
+  messages: DesignConversation['messages'];
+  requestHashes: Record<string, string>;
+  updatedAt: string;
+};
+
+type LegacyPersistedImageWorkspace = {
+  schemaVersion: 2;
+  workspaces: LegacyPersistedWorkspace[];
   tasksByWorkspaceId: Record<string, DesignGenerationTask[]>;
   assetsById: Record<string, PersistedAsset>;
 };
@@ -64,6 +94,7 @@ function createEmptyState(): PersistedImageWorkspace {
   return {
     schemaVersion: LOCAL_WORKSPACE_SCHEMA_VERSION,
     workspaces: [],
+    conversationsByWorkspaceId: {},
     tasksByWorkspaceId: {},
     assetsById: {},
   };
@@ -81,6 +112,15 @@ function isPersistedWorkspace(value: unknown): value is PersistedImageWorkspace
   return isRecord(value)
     && value.schemaVersion === LOCAL_WORKSPACE_SCHEMA_VERSION
     && Array.isArray(value.workspaces)
+    && isRecord(value.conversationsByWorkspaceId)
+    && isRecord(value.tasksByWorkspaceId)
+    && isRecord(value.assetsById);
+}
+
+function isLegacyPersistedWorkspace(value: unknown): value is LegacyPersistedImageWorkspace {
+  return isRecord(value)
+    && value.schemaVersion === 2
+    && Array.isArray(value.workspaces)
     && isRecord(value.tasksByWorkspaceId)
     && isRecord(value.assetsById);
 }
@@ -161,6 +201,7 @@ export function getLocalImageWorkspaceDirectory(userDataDir: string): string {
 export class LocalImageWorkspace implements DesignWorkspaceModule {
   private readonly rootDirectory: string;
   private readonly stateFile: string;
+  private readonly legacyStateFile: string;
   private readonly now: () => Date;
   private readonly createId: () => string;
   private state: PersistedImageWorkspace | null = null;
@@ -173,6 +214,7 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
       throw new Error('Invalid local AI design workspace directory');
     }
     this.stateFile = join(this.rootDirectory, LOCAL_WORKSPACE_FILE);
+    this.legacyStateFile = join(this.rootDirectory, LEGACY_LOCAL_WORKSPACE_FILE);
     this.now = options.now ?? (() => new Date());
     this.createId = options.createId ?? randomUUID;
   }
@@ -191,39 +233,71 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
   }
 
   createWorkspace(input: DesignCreateWorkspaceInput): Promise<DesignWorkspace> {
-    return this.mutate((state) => {
+    return this.mutateWorkspace((state) => {
       const existing = state.workspaces.find(
         (workspace) => workspace.clientWorkspaceId === input.clientWorkspaceId,
       );
       if (existing) return existing;
       const timestamp = this.now().toISOString();
+      const workspaceId = `local-workspace-${this.createId()}`;
       const workspace: PersistedWorkspace = {
-        workspaceId: `local-workspace-${this.createId()}`,
+        workspaceId,
         clientWorkspaceId: input.clientWorkspaceId,
         title: validateTitle(input.title),
-        turnRevision: 0,
         viewRevision: 0,
+        conversationCount: 1,
         phase: 'shaping',
-        brief: {
-          version: 0,
-          status: 'draft',
-          medium: null,
-          summary: '正在建立作品的视觉方向',
-          ready: false,
-          missingDecision: '作品形式',
-        },
-        messages: [],
-        requestHashes: {},
         updatedAt: timestamp,
       };
+      const conversation = this.createEmptyConversation(
+        workspaceId,
+        `local-conversation-${this.createId()}`,
+        `local-client-conversation-${this.createId()}`,
+        '新会话',
+        timestamp,
+      );
       state.workspaces.unshift(workspace);
-      state.tasksByWorkspaceId[workspace.workspaceId] = [];
+      state.conversationsByWorkspaceId[workspaceId] = [conversation];
+      state.tasksByWorkspaceId[workspaceId] = [];
       return workspace;
     });
   }
 
+  createConversation(input: DesignCreateConversationInput): Promise<DesignConversation> {
+    return this.mutateConversation((state) => {
+      const workspace = this.requireWorkspace(state, input.workspaceId);
+      const conversations = state.conversationsByWorkspaceId[input.workspaceId] ?? [];
+      const existing = conversations.find(
+        (conversation) => conversation.clientConversationId === input.clientConversationId,
+      );
+      if (existing) return existing;
+      const timestamp = this.now().toISOString();
+      const conversation = this.createEmptyConversation(
+        input.workspaceId,
+        `local-conversation-${this.createId()}`,
+        input.clientConversationId,
+        input.title,
+        timestamp,
+      );
+      conversations.unshift(conversation);
+      state.conversationsByWorkspaceId[input.workspaceId] = conversations;
+      workspace.conversationCount = conversations.length;
+      workspace.viewRevision += 1;
+      workspace.updatedAt = timestamp;
+      return conversation;
+    });
+  }
+
+  async getConversation(
+    workspaceId: string,
+    conversationId: string,
+  ): Promise<DesignConversation> {
+    const state = await this.load();
+    return clone(this.requireConversation(state, workspaceId, conversationId));
+  }
+
   renameWorkspace(input: DesignRenameWorkspaceInput): Promise<DesignWorkspace> {
-    return this.mutate((state) => {
+    return this.mutateWorkspace((state) => {
       const workspace = this.requireWorkspace(state, input.workspaceId);
       workspace.title = validateTitle(input.title);
       workspace.viewRevision += 1;
@@ -234,20 +308,25 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
 
   async getWorkspace(workspaceId: string): Promise<DesignWorkspace> {
     const state = await this.load();
-    return clone(this.requireWorkspace(state, workspaceId));
+    return this.workspaceView(state, this.requireWorkspace(state, workspaceId));
   }
 
-  submitMessage(input: DesignSubmitMessageInput): Promise<DesignWorkspace> {
-    return this.mutate((state) => {
+  submitMessage(input: DesignSubmitMessageInput): Promise<DesignConversation> {
+    return this.mutateConversation((state) => {
       const workspace = this.requireWorkspace(state, input.workspaceId);
+      const conversation = this.requireConversation(
+        state,
+        input.workspaceId,
+        input.conversationId,
+      );
       const message = validateMessage(input.message);
       const hash = messageHash(input);
-      if (this.isRequestReplay(workspace, input.clientTurnId, hash)) return workspace;
-      this.assertRevision(workspace, input.expectedTurnRevision);
-      this.supersedeQuotes(workspace);
+      if (this.isRequestReplay(conversation, input.clientTurnId, hash)) return conversation;
+      this.assertRevision(conversation, input.expectedTurnRevision);
+      this.supersedeQuotes(conversation);
 
       const timestamp = this.now().toISOString();
-      const nextRevision = workspace.turnRevision + 1;
+      const nextRevision = conversation.turnRevision + 1;
       const medium = detectMedium(message);
       const quote: DesignGenerationQuote = {
         quoteId: `local-quote-${this.createId()}`,
@@ -258,7 +337,7 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
         quotedDesignPoints: medium === 'video' ? 2 : 1,
         expiresAt: new Date(this.now().getTime() + 15 * 60 * 1000).toISOString(),
       };
-      workspace.messages.push(
+      conversation.messages.push(
         {
           id: `local-message-${this.createId()}`,
           role: 'user',
@@ -282,10 +361,9 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
           createdAt: timestamp,
         },
       );
-      workspace.turnRevision = nextRevision;
-      workspace.viewRevision += 1;
-      workspace.phase = 'awaiting_confirmation';
-      workspace.brief = {
+      conversation.turnRevision = nextRevision;
+      conversation.phase = 'awaiting_confirmation';
+      conversation.brief = {
         version: nextRevision,
         status: 'ready',
         medium,
@@ -293,19 +371,27 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
         ready: true,
         missingDecision: null,
       };
+      conversation.updatedAt = timestamp;
+      conversation.requestHashes[input.clientTurnId] = hash;
+      workspace.phase = conversation.phase;
+      workspace.viewRevision += 1;
       workspace.updatedAt = timestamp;
-      workspace.requestHashes[input.clientTurnId] = hash;
-      return workspace;
+      return conversation;
     });
   }
 
-  confirmGeneration(input: DesignConfirmGenerationInput): Promise<DesignWorkspace> {
-    return this.mutate((state) => {
+  confirmGeneration(input: DesignConfirmGenerationInput): Promise<DesignConversation> {
+    return this.mutateConversation((state) => {
       const workspace = this.requireWorkspace(state, input.workspaceId);
+      const conversation = this.requireConversation(
+        state,
+        input.workspaceId,
+        input.conversationId,
+      );
       const hash = messageHash(input);
-      if (this.isRequestReplay(workspace, input.clientTurnId, hash)) return workspace;
-      this.assertRevision(workspace, input.expectedTurnRevision);
-      const quote = workspace.messages
+      if (this.isRequestReplay(conversation, input.clientTurnId, hash)) return conversation;
+      this.assertRevision(conversation, input.expectedTurnRevision);
+      const quote = conversation.messages
         .map((message) => message.generationQuote)
         .find((candidate) => candidate?.quoteId === input.quoteId);
       if (!quote || quote.status !== 'active') {
@@ -318,8 +404,8 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
 
       quote.status = 'consumed';
       const timestamp = this.now().toISOString();
-      const nextRevision = workspace.turnRevision + 1;
-      workspace.messages.push(
+      const nextRevision = conversation.turnRevision + 1;
+      conversation.messages.push(
         {
           id: `local-message-${this.createId()}`,
           role: 'user',
@@ -341,16 +427,19 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
           createdAt: timestamp,
         },
       );
-      workspace.turnRevision = nextRevision;
+      conversation.turnRevision = nextRevision;
+      conversation.phase = 'shaping';
+      conversation.brief = { ...conversation.brief, status: 'confirmed' };
+      conversation.updatedAt = timestamp;
+      conversation.requestHashes[input.clientTurnId] = hash;
+      workspace.phase = conversation.phase;
       workspace.viewRevision += 1;
-      workspace.phase = 'shaping';
-      workspace.brief = { ...workspace.brief, status: 'confirmed' };
       workspace.updatedAt = timestamp;
-      workspace.requestHashes[input.clientTurnId] = hash;
       state.tasksByWorkspaceId[workspace.workspaceId] ??= [];
       state.tasksByWorkspaceId[workspace.workspaceId].unshift({
         taskId: `local-task-${this.createId()}`,
         workspaceId: workspace.workspaceId,
+        conversationId: conversation.conversationId,
         medium: quote.medium,
         status: 'queued',
         briefVersion: quote.briefVersion,
@@ -362,10 +451,39 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
         createdAt: timestamp,
         updatedAt: timestamp,
       });
-      return workspace;
+      return conversation;
     });
   }
 
+  private createEmptyConversation(
+    workspaceId: string,
+    conversationId: string,
+    clientConversationId: string,
+    title: string,
+    timestamp: string,
+  ): PersistedConversation {
+    return {
+      conversationId,
+      clientConversationId,
+      workspaceId,
+      title: validateTitle(title),
+      turnRevision: 0,
+      phase: 'shaping',
+      brief: {
+        version: 0,
+        status: 'draft',
+        medium: null,
+        summary: '正在建立作品的视觉方向',
+        ready: false,
+        missingDecision: '作品形式',
+      },
+      messages: [],
+      requestHashes: {},
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    };
+  }
+
   listTasks(workspaceId: string): Promise<DesignGenerationTask[]> {
     return this.enqueue(async () => {
       const state = await this.load();
@@ -443,14 +561,25 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
     });
   }
 
-  private mutate(
+  private mutateWorkspace(
     operation: (state: PersistedImageWorkspace) => PersistedWorkspace,
   ): Promise<DesignWorkspace> {
     return this.enqueue(async () => {
       const state = await this.load();
       const workspace = operation(state);
       await this.persist(state);
-      return clone(workspace);
+      return this.workspaceView(state, workspace);
+    });
+  }
+
+  private mutateConversation(
+    operation: (state: PersistedImageWorkspace) => PersistedConversation,
+  ): Promise<DesignConversation> {
+    return this.enqueue(async () => {
+      const state = await this.load();
+      const conversation = operation(state);
+      await this.persist(state);
+      return this.conversationView(conversation);
     });
   }
 
@@ -474,7 +603,7 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
       this.state = parsed;
     } catch (error) {
       if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
-        this.state = createEmptyState();
+        this.state = await this.loadLegacyState();
       } else {
         throw error;
       }
@@ -482,6 +611,62 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
     return this.state;
   }
 
+  private async loadLegacyState(): Promise<PersistedImageWorkspace> {
+    try {
+      const parsed = JSON.parse(await readFile(this.legacyStateFile, 'utf8')) as unknown;
+      if (!isLegacyPersistedWorkspace(parsed)) {
+        throw new LocalImageWorkspaceError(
+          500,
+          'IMAGE_WORKSPACE_LOCAL_DATA_INVALID',
+          'AI 设计本地数据暂时无法读取',
+        );
+      }
+      const migrated = this.migrateLegacyState(parsed);
+      await this.persist(migrated);
+      return migrated;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return createEmptyState();
+      throw error;
+    }
+  }
+
+  private migrateLegacyState(legacy: LegacyPersistedImageWorkspace): PersistedImageWorkspace {
+    const migrated = createEmptyState();
+    migrated.assetsById = clone(legacy.assetsById);
+    migrated.tasksByWorkspaceId = clone(legacy.tasksByWorkspaceId);
+    for (const legacyWorkspace of legacy.workspaces) {
+      const conversationId = `local-conversation-${this.createId()}`;
+      const createdAt = legacyWorkspace.messages[0]?.createdAt ?? legacyWorkspace.updatedAt;
+      const conversation: PersistedConversation = {
+        conversationId,
+        clientConversationId: `migrated-${legacyWorkspace.workspaceId}`,
+        workspaceId: legacyWorkspace.workspaceId,
+        title: '历史会话',
+        turnRevision: legacyWorkspace.turnRevision,
+        phase: legacyWorkspace.phase,
+        brief: clone(legacyWorkspace.brief),
+        messages: clone(legacyWorkspace.messages),
+        requestHashes: clone(legacyWorkspace.requestHashes),
+        createdAt,
+        updatedAt: legacyWorkspace.updatedAt,
+      };
+      migrated.workspaces.push({
+        workspaceId: legacyWorkspace.workspaceId,
+        clientWorkspaceId: legacyWorkspace.clientWorkspaceId,
+        title: legacyWorkspace.title,
+        viewRevision: legacyWorkspace.viewRevision,
+        conversationCount: 1,
+        phase: legacyWorkspace.phase,
+        updatedAt: legacyWorkspace.updatedAt,
+      });
+      migrated.conversationsByWorkspaceId[legacyWorkspace.workspaceId] = [conversation];
+      migrated.tasksByWorkspaceId[legacyWorkspace.workspaceId] = (
+        migrated.tasksByWorkspaceId[legacyWorkspace.workspaceId] ?? []
+      ).map((task) => ({ ...task, conversationId }));
+    }
+    return migrated;
+  }
+
   private async persist(state: PersistedImageWorkspace): Promise<void> {
     await mkdir(this.rootDirectory, { recursive: true });
     const temporaryFile = `${this.stateFile}.${process.pid}.tmp`;
@@ -508,22 +693,39 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
     return workspace;
   }
 
-  private assertRevision(workspace: PersistedWorkspace, expectedRevision: number): void {
-    if (workspace.turnRevision !== expectedRevision) {
+  private requireConversation(
+    state: PersistedImageWorkspace,
+    workspaceId: string,
+    conversationId: string,
+  ): PersistedConversation {
+    this.requireWorkspace(state, workspaceId);
+    const conversation = (state.conversationsByWorkspaceId[workspaceId] ?? [])
+      .find((item) => item.conversationId === conversationId);
+    if (!conversation) {
+      throw new LocalImageWorkspaceError(404, 'conversation_not_found', '设计会话不存在');
+    }
+    return conversation;
+  }
+
+  private assertRevision(
+    conversation: PersistedConversation,
+    expectedRevision: number,
+  ): void {
+    if (conversation.turnRevision !== expectedRevision) {
       throw new LocalImageWorkspaceError(
         409,
-        'workspace_revision_conflict',
-        '设计项目已在其他位置更新，请刷新后重试',
+        'conversation_revision_conflict',
+        '设计会话已在其他位置更新，请刷新后重试',
       );
     }
   }
 
   private isRequestReplay(
-    workspace: PersistedWorkspace,
+    conversation: PersistedConversation,
     clientTurnId: string,
     hash: string,
   ): boolean {
-    const existing = workspace.requestHashes[clientTurnId];
+    const existing = conversation.requestHashes[clientTurnId];
     if (!existing) return false;
     if (existing !== hash) {
       throw new LocalImageWorkspaceError(
@@ -535,8 +737,8 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
     return true;
   }
 
-  private supersedeQuotes(workspace: PersistedWorkspace): void {
-    for (const message of workspace.messages) {
+  private supersedeQuotes(conversation: PersistedConversation): void {
+    for (const message of conversation.messages) {
       if (message.generationQuote?.status === 'active') {
         message.generationQuote.status = 'superseded';
       }
@@ -546,7 +748,43 @@ export class LocalImageWorkspace implements DesignWorkspaceModule {
   private bootstrapView(state: PersistedImageWorkspace): DesignWorkspaceBootstrap {
     return {
       capabilities: clone(LOCAL_CAPABILITIES),
-      workspaces: state.workspaces.map(({ messages: _messages, clientWorkspaceId: _clientId, requestHashes: _requests, ...summary }) => clone(summary)),
+      workspaces: state.workspaces.map(({ clientWorkspaceId: _clientId, ...summary }) => (
+        clone(summary)
+      )),
     };
   }
+
+  private workspaceView(
+    state: PersistedImageWorkspace,
+    workspace: PersistedWorkspace,
+  ): DesignWorkspace {
+    const { clientWorkspaceId: _clientId, ...summary } = workspace;
+    return clone({
+      ...summary,
+      conversationCount: state.conversationsByWorkspaceId[workspace.workspaceId]?.length ?? 0,
+      conversations: (state.conversationsByWorkspaceId[workspace.workspaceId] ?? [])
+        .map((conversation) => this.conversationSummaryView(conversation)),
+    });
+  }
+
+  private conversationSummaryView(
+    conversation: PersistedConversation,
+  ): DesignConversationSummary {
+    const {
+      clientConversationId: _clientId,
+      requestHashes: _requestHashes,
+      messages: _messages,
+      ...summary
+    } = conversation;
+    return clone(summary);
+  }
+
+  private conversationView(conversation: PersistedConversation): DesignConversation {
+    const {
+      clientConversationId: _clientId,
+      requestHashes: _requestHashes,
+      ...view
+    } = conversation;
+    return clone(view);
+  }
 }
diff --git a/electron/image-workspace/module.ts b/electron/image-workspace/module.ts
index 58b90c3..34e4ea9 100644
--- a/electron/image-workspace/module.ts
+++ b/electron/image-workspace/module.ts
@@ -2,6 +2,8 @@ import type {
   DesignAsset,
   DesignAssetUploadInput,
   DesignCapabilities,
+  DesignConversation,
+  DesignCreateConversationInput,
   DesignConfirmGenerationInput,
   DesignCreateWorkspaceInput,
   DesignGenerationTask,
@@ -19,6 +21,7 @@ export type DesignWorkspaceEventSubscription = {
 
 export type DesignWorkspaceEventSubscriptionInput = {
   workspaceId: string;
+  conversationId: string;
   afterEventId?: string;
 };
 
@@ -45,8 +48,10 @@ export interface DesignWorkspaceModule {
   createWorkspace(input: DesignCreateWorkspaceInput): Promise<DesignWorkspace>;
   renameWorkspace(input: DesignRenameWorkspaceInput): Promise<DesignWorkspace>;
   getWorkspace(workspaceId: string): Promise<DesignWorkspace>;
-  submitMessage(input: DesignSubmitMessageInput): Promise<DesignWorkspace>;
-  confirmGeneration(input: DesignConfirmGenerationInput): Promise<DesignWorkspace>;
+  createConversation(input: DesignCreateConversationInput): Promise<DesignConversation>;
+  getConversation(workspaceId: string, conversationId: string): Promise<DesignConversation>;
+  submitMessage(input: DesignSubmitMessageInput): Promise<DesignConversation>;
+  confirmGeneration(input: DesignConfirmGenerationInput): Promise<DesignConversation>;
   listTasks(workspaceId: string): Promise<DesignGenerationTask[]>;
   uploadAsset?(input: DesignAssetUploadInput): Promise<DesignAsset>;
   openWorkspaceEvents?(
diff --git a/electron/image-workspace/works-square-workspace.ts b/electron/image-workspace/works-square-workspace.ts
index b4e6937..3a5c496 100644
--- a/electron/image-workspace/works-square-workspace.ts
+++ b/electron/image-workspace/works-square-workspace.ts
@@ -4,11 +4,14 @@ import type {
   DesignAssistantDeltaEvent,
   DesignBrief,
   DesignCapabilities,
+  DesignConversation,
+  DesignConversationSnapshotEvent,
+  DesignConversationSummary,
   DesignConfirmGenerationInput,
+  DesignCreateConversationInput,
   DesignCreateWorkspaceInput,
   DesignGenerationQuote,
   DesignGenerationTask,
-  DesignGenerationTasksSnapshotEvent,
   DesignGenerationTaskUpdatedEvent,
   DesignMessage,
   DesignRenameWorkspaceInput,
@@ -18,7 +21,6 @@ import type {
   DesignWorkspaceEvent,
   DesignWorkspaceSummary,
 } from '../../shared/image-workspace';
-import { createHash } from 'node:crypto';
 import WebSocket from 'ws';
 import { designAssetContentPath } from '../../shared/image-workspace';
 import { WORKS_SQUARE_CONFIG } from '../api/works-config';
@@ -26,7 +28,6 @@ import { proxyAwareFetch } from '../utils/proxy-fetch';
 import { getValidWorksSquareAccessToken } from '../services/works-square-session';
 import {
   DesignWorkspaceModuleError,
-  type CloseEventSessionsOptions,
   type DesignWorkspaceEventSubscription,
   type DesignWorkspaceEventSubscriptionInput,
   type DesignWorkspaceModule,
@@ -64,17 +65,36 @@ type ServerMessage = {
 type ServerWorkspaceSummary = {
   workspace_id: string;
   title: string;
-  turn_revision: number;
   view_revision: number;
+  conversation_count?: number;
   phase: DesignWorkspaceSummary['phase'];
-  brief: ServerBrief;
   updated_at: string;
 };
 
-type ServerWorkspace = ServerWorkspaceSummary & {
+type ServerConversationSummary = {
+  conversation_id: string;
+  workspace_id: string;
+  agent_session_id: string | null;
+  title: string;
+  turn_revision: number;
+  phase: DesignConversationSummary['phase'];
+  brief: ServerBrief;
+  created_at: string;
+  updated_at: string;
+};
+
+type ServerConversation = ServerConversationSummary & {
   messages: ServerMessage[];
 };
 
+type ServerWorkspace = ServerWorkspaceSummary & {
+  conversations?: ServerConversationSummary[];
+};
+
+type ServerWorkspaceCreation = ServerWorkspace & {
+  initial_conversation?: ServerConversation;
+};
+
 type ServerAsset = {
   asset_id: string;
   media_type: DesignAsset['mediaType'];
@@ -88,6 +108,7 @@ type ServerAsset = {
 type ServerTask = {
   task_id: string;
   workspace_id: string;
+  conversation_id?: string | null;
   medium: DesignGenerationTask['medium'];
   status: DesignGenerationTask['status'];
   brief_version: number;
@@ -108,17 +129,7 @@ type ServerErrorDetail = {
 type WorksSquareDesignWorkspaceOptions = {
   apiBaseUrl?: string;
   fetchImpl?: typeof fetch;
-  clientInstanceId?: string;
   webSocketFactory?: AgentWebSocketFactory;
-  eventSessionClientIdStore?: {
-    getOrCreate(workspaceId: string): Promise<string>;
-    rotate(workspaceId: string): Promise<string>;
-  };
-};
-
-type ServerAgentSession = {
-  session_id: string;
-  status: 'active' | 'closed';
 };
 
 type ServerAgentStreamTicket = {
@@ -155,6 +166,8 @@ type ServerAgentRun = {
 
 type AgentDesignTurnSubmission = {
   workspaceId: string;
+  conversationId: string;
+  agentSessionId: string;
   clientTurnId: string;
   expectedTurnRevision: number;
   message: string;
@@ -233,19 +246,42 @@ function mapWorkspaceSummary(workspace: ServerWorkspaceSummary): DesignWorkspace
   return {
     workspaceId: workspace.workspace_id,
     title: workspace.title,
-    turnRevision: workspace.turn_revision,
     viewRevision: workspace.view_revision,
+    conversationCount: workspace.conversation_count ?? 0,
     phase: workspace.phase,
-    brief: mapBrief(workspace.brief),
     updatedAt: workspace.updated_at,
   };
 }
 
 function mapWorkspace(workspace: ServerWorkspace): DesignWorkspace {
+  const conversations = workspace.conversations ?? [];
   return {
     ...mapWorkspaceSummary(workspace),
-    messages: workspace.messages.map((message, index) => ({
-      id: `${workspace.workspace_id}:${message.turn_revision}:${message.role}:${index}`,
+    conversationCount: workspace.conversation_count ?? conversations.length,
+    conversations: conversations.map(mapConversationSummary),
+  };
+}
+
+function mapConversationSummary(
+  conversation: ServerConversationSummary,
+): DesignConversationSummary {
+  return {
+    conversationId: conversation.conversation_id,
+    workspaceId: conversation.workspace_id,
+    title: conversation.title,
+    turnRevision: conversation.turn_revision,
+    phase: conversation.phase,
+    brief: mapBrief(conversation.brief),
+    createdAt: conversation.created_at,
+    updatedAt: conversation.updated_at,
+  };
+}
+
+function mapConversation(conversation: ServerConversation): DesignConversation {
+  return {
+    ...mapConversationSummary(conversation),
+    messages: conversation.messages.map((message, index) => ({
+      id: `${conversation.conversation_id}:${message.turn_revision}:${message.role}:${index}`,
       role: message.role,
       kind: message.kind,
       text: message.text,
@@ -261,6 +297,7 @@ function mapTask(task: ServerTask): DesignGenerationTask {
   return {
     taskId: task.task_id,
     workspaceId: task.workspace_id,
+    conversationId: task.conversation_id ?? null,
     medium: task.medium,
     status: task.status,
     briefVersion: task.brief_version,
@@ -288,24 +325,14 @@ function mapAsset(workspaceId: string, asset: ServerAsset): DesignAsset {
   };
 }
 
-function createClientId(prefix: string): string {
-  const id = globalThis.crypto?.randomUUID?.()
-    ?? `${Date.now()}-${Math.random().toString(16).slice(2)}`;
-  return `${prefix}-${id}`;
-}
-
-function stableWorkspaceSessionClientId(clientInstanceId: string, workspaceId: string): string {
-  const digest = createHash('sha256')
-    .update(`${clientInstanceId}\0${workspaceId}`)
-    .digest('hex');
-  return `design-stream-${digest}`;
-}
-
 function isServerTask(value: unknown): value is ServerTask {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
   const task = value as Record<string, unknown>;
   return typeof task.task_id === 'string'
     && typeof task.workspace_id === 'string'
+    && (task.conversation_id === undefined
+      || task.conversation_id === null
+      || typeof task.conversation_id === 'string')
     && (task.medium === 'image' || task.medium === 'video')
     && ['queued', 'running', 'succeeded', 'failed', 'cancelled'].includes(String(task.status))
     && typeof task.brief_version === 'number'
@@ -315,17 +342,18 @@ function isServerTask(value: unknown): value is ServerTask {
     && typeof task.updated_at === 'string';
 }
 
-function isServerWorkspace(value: unknown): value is ServerWorkspace {
+function isServerConversation(value: unknown): value is ServerConversation {
   if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
-  const workspace = value as Record<string, unknown>;
-  const brief = workspace.brief as Record<string, unknown> | null;
-  return typeof workspace.workspace_id === 'string'
-    && typeof workspace.title === 'string'
-    && Number.isInteger(workspace.turn_revision)
-    && Number(workspace.turn_revision) >= 0
-    && Number.isInteger(workspace.view_revision)
-    && Number(workspace.view_revision) >= 0
-    && ['shaping', 'awaiting_confirmation', 'blocked'].includes(String(workspace.phase))
+  const conversation = value as Record<string, unknown>;
+  const brief = conversation.brief as Record<string, unknown> | null;
+  return typeof conversation.conversation_id === 'string'
+    && typeof conversation.workspace_id === 'string'
+    && (conversation.agent_session_id === null
+      || typeof conversation.agent_session_id === 'string')
+    && typeof conversation.title === 'string'
+    && Number.isInteger(conversation.turn_revision)
+    && Number(conversation.turn_revision) >= 0
+    && ['shaping', 'awaiting_confirmation', 'blocked'].includes(String(conversation.phase))
     && Boolean(brief)
     && Number.isInteger(brief?.version)
     && ['draft', 'ready', 'confirmed'].includes(String(brief?.status))
@@ -333,8 +361,8 @@ function isServerWorkspace(value: unknown): value is ServerWorkspace {
     && typeof brief?.summary === 'string'
     && typeof brief?.ready === 'boolean'
     && (brief?.missing_decision === null || typeof brief?.missing_decision === 'string')
-    && Array.isArray(workspace.messages)
-    && workspace.messages.every((message) => {
+    && Array.isArray(conversation.messages)
+    && conversation.messages.every((message) => {
       if (!message || typeof message !== 'object' || Array.isArray(message)) return false;
       const item = message as Record<string, unknown>;
       return (item.role === 'user' || item.role === 'assistant')
@@ -347,13 +375,15 @@ function isServerWorkspace(value: unknown): value is ServerWorkspace {
         && Number(item.turn_revision) >= 0
         && typeof item.created_at === 'string';
     })
-    && typeof workspace.updated_at === 'string';
+    && typeof conversation.created_at === 'string'
+    && typeof conversation.updated_at === 'string';
 }
 
 function normalizeWorkspaceEvent(
   value: unknown,
   sessionId: string,
   workspaceId: string,
+  conversationId: string,
 ): DesignWorkspaceEvent | null {
   try {
     if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
@@ -371,6 +401,7 @@ function normalizeWorkspaceEvent(
     const payload = event.payload as Record<string, unknown>;
     if (event.type === 'design.assistant.delta') {
       if (payload.workspace_id !== workspaceId
+        || payload.conversation_id !== conversationId
         || typeof payload.client_turn_id !== 'string'
         || payload.client_turn_id.length < 1
         || payload.client_turn_id.length > 128
@@ -387,6 +418,7 @@ function normalizeWorkspaceEvent(
         id: `${sessionId}:${event.sequence}`,
         type: 'design.assistant.delta',
         workspaceId,
+        conversationId,
         clientTurnId: payload.client_turn_id,
         turnRevision: Number(payload.turn_revision),
         chunkIndex: Number(payload.chunk_index),
@@ -411,15 +443,19 @@ function normalizeWorkspaceEvent(
       } satisfies DesignGenerationTaskUpdatedEvent;
     }
 
-    if (event.type !== 'design.workspace.updated'
-      || !isServerWorkspace(payload.workspace)
+    if ((event.type !== 'design.conversation.updated'
+        && event.type !== 'design.workspace.updated')
+      || payload.workspace_id !== workspaceId
+      || payload.conversation_id !== conversationId
+      || !isServerConversation(payload.conversation)
       || !Array.isArray(payload.generation_tasks)) {
       return null;
     }
-    const workspace = payload.workspace;
-    if (workspace.workspace_id !== workspaceId
-      || !Number.isInteger(workspace.view_revision)
-      || Number(workspace.view_revision) < 0
+    const conversation = payload.conversation;
+    if (conversation.workspace_id !== workspaceId
+      || conversation.conversation_id !== conversationId
+      || !Number.isInteger(payload.workspace_view_revision)
+      || Number(payload.workspace_view_revision) < 0
       || !payload.generation_tasks.every(
         (task) => isServerTask(task) && task.workspace_id === workspaceId,
       )) {
@@ -427,12 +463,13 @@ function normalizeWorkspaceEvent(
     }
     return {
       id: `${sessionId}:${event.sequence}`,
-      type: 'design.generation_tasks.snapshot',
+      type: 'design.conversation.snapshot',
       workspaceId,
-      workspaceViewRevision: Number(workspace.view_revision),
-      workspace: mapWorkspace(workspace),
+      conversationId,
+      workspaceViewRevision: Number(payload.workspace_view_revision),
+      conversation: mapConversation(conversation),
       generationTasks: payload.generation_tasks.map((task) => mapTask(task as ServerTask)),
-    } satisfies DesignGenerationTasksSnapshotEvent;
+    } satisfies DesignConversationSnapshotEvent;
   } catch {
     return null;
   }
@@ -669,15 +706,17 @@ function agentRunErrorStatus(code: string): number {
   return 502;
 }
 
+function isStaleAgentSessionError(error: unknown): error is DesignWorkspaceModuleError {
+  return error instanceof DesignWorkspaceModuleError
+    && (error.code === 'agent_session_not_found'
+      || error.code === 'agent_session_closed');
+}
+
 export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
   private readonly apiBaseUrl: string;
   private readonly fetchImpl: typeof fetch;
   private readonly webSocketFactory: AgentWebSocketFactory;
-  private readonly eventSessionClientIdStore: NonNullable<
-    WorksSquareDesignWorkspaceOptions['eventSessionClientIdStore']
-  >;
-  private readonly eventSessions = new Map<string, Promise<ServerAgentSession>>();
-  private readonly eventSessionClientIds = new Map<string, string>();
+  private readonly conversationSessionIds = new Map<string, string>();
   private readonly eventSubscriptionClosers = new Map<string, Set<() => void>>();
   private readonly activeRunEventStreams = new Map<string, number>();
   private readonly terminalAgentRuns = new Map<string, ServerAgentRun>();
@@ -689,13 +728,6 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     this.apiBaseUrl = (options.apiBaseUrl ?? WORKS_SQUARE_CONFIG.apiBaseUrl).replace(/\/+$/, '');
     this.fetchImpl = options.fetchImpl ?? proxyAwareFetch;
     this.webSocketFactory = options.webSocketFactory ?? defaultAgentWebSocketFactory;
-    const clientInstanceId = options.clientInstanceId?.trim() || createClientId('process');
-    this.eventSessionClientIdStore = options.eventSessionClientIdStore ?? {
-      getOrCreate: async (workspaceId) => (
-        stableWorkspaceSessionClientId(clientInstanceId, workspaceId)
-      ),
-      rotate: async () => createClientId('design-stream-rotated'),
-    };
   }
 
   async bootstrap(): Promise<DesignWorkspaceBootstrap> {
@@ -715,14 +747,15 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
   }
 
   async createWorkspace(input: DesignCreateWorkspaceInput): Promise<DesignWorkspace> {
-    const workspace = await this.requestJson<ServerWorkspace>('/api/design/workspaces', {
+    const workspace = await this.requestJson<ServerWorkspaceCreation>('/api/design/workspaces', {
       method: 'POST',
       body: JSON.stringify({
         client_workspace_id: input.clientWorkspaceId,
         title: input.title,
       }),
     });
-    return mapWorkspace(workspace);
+    if (workspace.initial_conversation) this.rememberConversation(workspace.initial_conversation);
+    return this.getWorkspace(workspace.workspace_id);
   }
 
   async renameWorkspace(input: DesignRenameWorkspaceInput): Promise<DesignWorkspace> {
@@ -733,19 +766,53 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
         body: JSON.stringify({ title: input.title }),
       },
     );
-    return mapWorkspace(workspace);
+    return this.getWorkspace(workspace.workspace_id);
   }
 
   async getWorkspace(workspaceId: string): Promise<DesignWorkspace> {
-    const workspace = await this.requestJson<ServerWorkspace>(
-      `/api/design/workspaces/${encodeURIComponent(workspaceId)}`,
-    );
-    return mapWorkspace(workspace);
+    const [workspace, conversations] = await Promise.all([
+      this.requestJson<ServerWorkspace>(
+        `/api/design/workspaces/${encodeURIComponent(workspaceId)}`,
+      ),
+      this.requestJson<ServerConversationSummary[]>(
+        `/api/design/workspaces/${encodeURIComponent(workspaceId)}/conversations?limit=100&offset=0`,
+      ),
+    ]);
+    return mapWorkspace({ ...workspace, conversations });
   }
 
-  async submitMessage(input: DesignSubmitMessageInput): Promise<DesignWorkspace> {
+  async createConversation(input: DesignCreateConversationInput): Promise<DesignConversation> {
+    const conversation = await this.requestJson<ServerConversation>(
+      `/api/design/workspaces/${encodeURIComponent(input.workspaceId)}/conversations`,
+      {
+        method: 'POST',
+        body: JSON.stringify({
+          client_conversation_id: input.clientConversationId,
+          title: input.title,
+        }),
+      },
+    );
+    this.rememberConversation(conversation);
+    return mapConversation(conversation);
+  }
+
+  async getConversation(
+    workspaceId: string,
+    conversationId: string,
+  ): Promise<DesignConversation> {
+    const conversation = await this.requestJson<ServerConversation>(
+      `/api/design/workspaces/${encodeURIComponent(workspaceId)}/conversations/${encodeURIComponent(conversationId)}`,
+    );
+    this.rememberConversation(conversation);
+    return mapConversation(conversation);
+  }
+
+  async submitMessage(input: DesignSubmitMessageInput): Promise<DesignConversation> {
+    const agentSessionId = await this.getAgentSessionId(input.workspaceId, input.conversationId);
     return this.executeAgentTurn({
       workspaceId: input.workspaceId,
+      conversationId: input.conversationId,
+      agentSessionId,
       clientTurnId: input.clientTurnId,
       expectedTurnRevision: input.expectedTurnRevision,
       message: input.message,
@@ -754,9 +821,12 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     });
   }
 
-  async confirmGeneration(input: DesignConfirmGenerationInput): Promise<DesignWorkspace> {
+  async confirmGeneration(input: DesignConfirmGenerationInput): Promise<DesignConversation> {
+    const agentSessionId = await this.getAgentSessionId(input.workspaceId, input.conversationId);
     return this.executeAgentTurn({
       workspaceId: input.workspaceId,
+      conversationId: input.conversationId,
+      agentSessionId,
       clientTurnId: input.clientTurnId,
       expectedTurnRevision: input.expectedTurnRevision,
       message: '确认生成',
@@ -768,22 +838,23 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     });
   }
 
-  private async executeAgentTurn(input: AgentDesignTurnSubmission): Promise<DesignWorkspace> {
-    let session = await this.ensureEventSession(input.workspaceId);
-    let command: ServerAgentCommand;
+  private async executeAgentTurn(input: AgentDesignTurnSubmission): Promise<DesignConversation> {
     try {
-      command = await this.submitTurnCommand(session.session_id, input);
+      return await this.executeAgentTurnOnce(input);
     } catch (error) {
-      if (!(error instanceof DesignWorkspaceModuleError)
-        || (error.code !== 'agent_session_not_found'
-          && error.code !== 'agent_session_closed')) {
-        throw error;
-      }
-      await this.invalidateEventSession(input.workspaceId);
-      session = await this.ensureEventSession(input.workspaceId);
-      command = await this.submitTurnCommand(session.session_id, input);
+      if (!isStaleAgentSessionError(error)) throw error;
+      this.forgetConversation(input.workspaceId, input.conversationId);
+      const agentSessionId = await this.getAgentSessionId(
+        input.workspaceId,
+        input.conversationId,
+      );
+      return this.executeAgentTurnOnce({ ...input, agentSessionId });
     }
-    const run = await this.waitForAgentRun(session.session_id, command.run_id);
+  }
+
+  private async executeAgentTurnOnce(input: AgentDesignTurnSubmission): Promise<DesignConversation> {
+    const command = await this.submitTurnCommand(input.agentSessionId, input);
+    const run = await this.waitForAgentRun(input.agentSessionId, command.run_id);
     if (run.status !== 'succeeded') {
       const code = run.error?.code ?? (
         run.status === 'cancelled' ? 'design_agent_run_cancelled' : 'design_agent_run_failed'
@@ -799,7 +870,7 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
         userFacingErrorMessage(code, fallback),
       );
     }
-    return this.getWorkspace(input.workspaceId);
+    return this.getConversation(input.workspaceId, input.conversationId);
   }
 
   private submitTurnCommand(
@@ -936,18 +1007,24 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
   async openWorkspaceEvents(
     input: DesignWorkspaceEventSubscriptionInput,
   ): Promise<DesignWorkspaceEventSubscription> {
-    let session = await this.ensureEventSession(input.workspaceId);
+    if (!this.eventSessionsEnabled) {
+      throw new DesignWorkspaceModuleError(
+        503,
+        'DESIGN_EVENT_STREAM_PAUSED',
+        'AI 设计任务状态流已暂停',
+      );
+    }
+    let sessionId = await this.getAgentSessionId(input.workspaceId, input.conversationId);
     let ticket: ServerAgentStreamTicket;
     try {
-      ticket = await this.createEventStreamTicket(session.session_id);
+      ticket = await this.createEventStreamTicket(sessionId);
     } catch (error) {
-      if (!(error instanceof DesignWorkspaceModuleError)
-        || (error.status !== 404 && error.status !== 409)) {
+      if (!isStaleAgentSessionError(error)) {
         throw error;
       }
-      await this.invalidateEventSession(input.workspaceId);
-      session = await this.ensureEventSession(input.workspaceId);
-      ticket = await this.createEventStreamTicket(session.session_id);
+      this.forgetConversation(input.workspaceId, input.conversationId);
+      sessionId = await this.getAgentSessionId(input.workspaceId, input.conversationId);
+      ticket = await this.createEventStreamTicket(sessionId);
     }
     const streamUrl = new URL(ticket.stream_url, `${this.apiBaseUrl}/`);
     if (streamUrl.origin !== new URL(this.apiBaseUrl).origin) {
@@ -966,7 +1043,7 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     }
     streamUrl.searchParams.set(
       'after_sequence',
-      String(eventSequence(input.afterEventId, session.session_id)),
+      String(eventSequence(input.afterEventId, sessionId)),
     );
     streamUrl.protocol = streamUrl.protocol === 'https:' ? 'wss:' : 'ws:';
 
@@ -1010,7 +1087,7 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
       if (heartbeat !== null) clearInterval(heartbeat);
       heartbeat = null;
       unregister();
-      if (didOpen) this.unregisterRunEventStream(session.session_id);
+      if (didOpen) this.unregisterRunEventStream(sessionId);
       try {
         await connection.dispose?.();
       } catch {
@@ -1053,7 +1130,7 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     socket.onopen = () => {
       if (ending) return;
       didOpen = true;
-      this.registerRunEventStream(session.session_id);
+      this.registerRunEventStream(sessionId);
       heartbeat = setInterval(() => {
         if (ending || socket.readyState !== AGENT_WEBSOCKET_OPEN) return;
         try {
@@ -1072,16 +1149,17 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
       const agentEvent = agentEventFromWebSocketFrame(data);
       const event = normalizeWorkspaceEvent(
         agentEvent,
-        session.session_id,
+        sessionId,
         input.workspaceId,
+        input.conversationId,
       );
       if (event) {
         latestWorkspaceEventDelivery = boundedTaskEventDelivery(queue.push(event));
       }
-      const run = normalizeAgentRunEvent(agentEvent, session.session_id);
+      const run = normalizeAgentRunEvent(agentEvent, sessionId);
       if (run) {
         const deliveryBarrier = latestWorkspaceEventDelivery;
-        void deliveryBarrier.then(() => this.publishAgentRun(session.session_id, run));
+        void deliveryBarrier.then(() => this.publishAgentRun(sessionId, run));
       }
     };
     socket.onerror = () => {
@@ -1091,23 +1169,19 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     };
     socket.onclose = ({ code }) => {
       const error = webSocketCloseError(code);
-      if (code === 4409) {
-        beginEnd(error, async () => {
-          try {
-            await this.closeEventSession(session.session_id);
-          } finally {
-            await this.invalidateEventSession(input.workspaceId);
-          }
+      if (code === 4409 || code === 4404) {
+        beginEnd(error, () => {
+          this.forgetConversation(input.workspaceId, input.conversationId);
         });
         return;
       }
-      if (code === 4404) {
-        beginEnd(error, () => this.invalidateEventSession(input.workspaceId));
-        return;
-      }
       beginEnd(error);
     };
-    unregister = this.registerEventSubscription(input.workspaceId, close);
+    unregister = this.registerEventSubscription(
+      input.workspaceId,
+      input.conversationId,
+      close,
+    );
     await opened;
     return {
       events: queue.events,
@@ -1115,53 +1189,13 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     };
   }
 
-  async closeEventSessions(options: CloseEventSessionsOptions = {}): Promise<void> {
+  async closeEventSessions(): Promise<void> {
     this.eventSessionsEnabled = false;
     const activeSubscriptions = [...this.eventSubscriptionClosers.values()]
       .flatMap((closers) => [...closers]);
     this.eventSubscriptionClosers.clear();
     for (const close of activeSubscriptions) close();
-    const pendingSessions = [...this.eventSessions.entries()];
-    this.eventSessions.clear();
-    const sessions = await Promise.all(pendingSessions.map(async ([workspaceId, pending]) => {
-      try {
-        return { workspaceId, session: await pending, creationError: null as unknown };
-      } catch (error) {
-        return { workspaceId, session: null, creationError: error };
-      }
-    }));
-    const closeResults = await Promise.all(sessions.map(async ({
-      workspaceId,
-      session,
-      creationError,
-    }) => {
-      let remoteError = creationError;
-      if (session) {
-        try {
-          await this.closeEventSession(session.session_id, options.accessToken);
-        } catch (error) {
-          remoteError = error;
-        }
-      }
-
-      let rotationError: unknown = null;
-      try {
-        await this.rotateEventSession(workspaceId);
-      } catch (error) {
-        rotationError = error;
-      }
-      return { remoteError, rotationError };
-    }));
-    const failed = closeResults.filter(({ remoteError, rotationError }) => (
-      Boolean(rotationError)
-      || (!options.tolerateRemoteFailure
-        && Boolean(remoteError)
-        && !(remoteError instanceof DesignWorkspaceModuleError
-          && remoteError.code === 'DESIGN_EVENT_SESSION_CLOSED'))
-    )).length;
-    if (failed > 0) {
-      throw new Error(`Failed to close ${failed} AI design Agent Session(s)`);
-    }
+    this.conversationSessionIds.clear();
   }
 
   openAssetContent(workspaceId: string, assetId: string, range?: string): Promise<Response> {
@@ -1171,11 +1205,7 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     );
   }
 
-  private async requestJson<T>(
-    path: string,
-    init: RequestInit = {},
-    accessToken?: string,
-  ): Promise<T> {
+  private async requestJson<T>(path: string, init: RequestInit = {}): Promise<T> {
     const response = await this.authorizedFetch(path, {
       ...init,
       headers: {
@@ -1185,7 +1215,7 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
           : {}),
         ...(init.headers ?? {}),
       },
-    }, accessToken);
+    });
     const payload = await readPayload(response);
     if (!response.ok) {
       const detail = asErrorDetail(payload);
@@ -1204,12 +1234,7 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     return payload as T;
   }
 
-  private async authorizedFetch(
-    path: string,
-    init: RequestInit = {},
-    accessToken?: string,
-  ): Promise<Response> {
-    if (accessToken) return this.fetchWithToken(path, accessToken, init);
+  private async authorizedFetch(path: string, init: RequestInit = {}): Promise<Response> {
     let token = await getValidWorksSquareAccessToken({ fetchImpl: this.fetchImpl });
     if (!token) {
       throw new DesignWorkspaceModuleError(401, 'AUTH_REQUIRED', '请先登录后再使用 AI 设计');
@@ -1239,50 +1264,40 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     });
   }
 
-  private ensureEventSession(workspaceId: string): Promise<ServerAgentSession> {
-    if (!this.eventSessionsEnabled) {
+  private conversationKey(workspaceId: string, conversationId: string): string {
+    return `${workspaceId}:${conversationId}`;
+  }
+
+  private rememberConversation(conversation: ServerConversationSummary): void {
+    if (typeof conversation.agent_session_id !== 'string'
+      || !conversation.agent_session_id.trim()) return;
+    this.conversationSessionIds.set(
+      this.conversationKey(conversation.workspace_id, conversation.conversation_id),
+      conversation.agent_session_id,
+    );
+  }
+
+  private forgetConversation(workspaceId: string, conversationId: string): void {
+    this.conversationSessionIds.delete(this.conversationKey(workspaceId, conversationId));
+  }
+
+  private async getAgentSessionId(
+    workspaceId: string,
+    conversationId: string,
+  ): Promise<string> {
+    const key = this.conversationKey(workspaceId, conversationId);
+    const existing = this.conversationSessionIds.get(key);
+    if (existing) return existing;
+    await this.getConversation(workspaceId, conversationId);
+    const refreshed = this.conversationSessionIds.get(key);
+    if (!refreshed) {
       throw new DesignWorkspaceModuleError(
         503,
-        'DESIGN_EVENT_STREAM_PAUSED',
-        'AI 设计任务状态流已暂停',
+        'DESIGN_CONVERSATION_SESSION_UNAVAILABLE',
+        '设计会话暂时无法连接，请稍后重试',
       );
     }
-    const existing = this.eventSessions.get(workspaceId);
-    if (existing) return existing;
-    const pending = (async () => {
-      const clientSessionId = this.eventSessionClientIds.get(workspaceId)
-        ?? await this.eventSessionClientIdStore.getOrCreate(workspaceId);
-      this.eventSessionClientIds.set(workspaceId, clientSessionId);
-      const session = await this.requestJson<ServerAgentSession>('/api/agents/sessions', {
-        method: 'POST',
-        body: JSON.stringify({
-          client_session_id: clientSessionId,
-          runtime: 'design',
-          runtime_version: 'v1',
-          binding: {
-            kind: 'design_workspace',
-            key: workspaceId,
-          },
-        }),
-      });
-      if (session.status !== 'active') {
-        throw new DesignWorkspaceModuleError(
-          409,
-          'DESIGN_EVENT_SESSION_CLOSED',
-          'AI 设计任务状态会话已关闭',
-        );
-      }
-      return session;
-    })().catch(async (error) => {
-      this.eventSessions.delete(workspaceId);
-      if (error instanceof DesignWorkspaceModuleError
-        && error.code === 'DESIGN_EVENT_SESSION_CLOSED') {
-        await this.rotateEventSession(workspaceId);
-      }
-      throw error;
-    });
-    this.eventSessions.set(workspaceId, pending);
-    return pending;
+    return refreshed;
   }
 
   private createEventStreamTicket(sessionId: string): Promise<ServerAgentStreamTicket> {
@@ -1295,13 +1310,18 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     );
   }
 
-  private registerEventSubscription(workspaceId: string, close: () => void): () => void {
-    const closers = this.eventSubscriptionClosers.get(workspaceId) ?? new Set<() => void>();
+  private registerEventSubscription(
+    workspaceId: string,
+    conversationId: string,
+    close: () => void,
+  ): () => void {
+    const key = this.conversationKey(workspaceId, conversationId);
+    const closers = this.eventSubscriptionClosers.get(key) ?? new Set<() => void>();
     closers.add(close);
-    this.eventSubscriptionClosers.set(workspaceId, closers);
+    this.eventSubscriptionClosers.set(key, closers);
     return () => {
       closers.delete(close);
-      if (closers.size === 0) this.eventSubscriptionClosers.delete(workspaceId);
+      if (closers.size === 0) this.eventSubscriptionClosers.delete(key);
     };
   }
 
@@ -1339,28 +1359,4 @@ export class WorksSquareDesignWorkspace implements DesignWorkspaceModule {
     for (const resolve of waiters) resolve(run);
   }
 
-  private async closeEventSession(sessionId: string, accessToken?: string): Promise<void> {
-    try {
-      await this.requestJson<ServerAgentSession>(
-        `/api/agents/sessions/${encodeURIComponent(sessionId)}`,
-        { method: 'DELETE' },
-        accessToken,
-      );
-    } catch (error) {
-      if (error instanceof DesignWorkspaceModuleError
-        && (error.status === 404 || error.status === 409)) return;
-      throw error;
-    }
-  }
-
-  private invalidateEventSession(workspaceId: string): Promise<void> {
-    return this.rotateEventSession(workspaceId).then(() => undefined);
-  }
-
-  private async rotateEventSession(workspaceId: string): Promise<string> {
-    this.eventSessions.delete(workspaceId);
-    const clientSessionId = await this.eventSessionClientIdStore.rotate(workspaceId);
-    this.eventSessionClientIds.set(workspaceId, clientSessionId);
-    return clientSessionId;
-  }
 }
diff --git a/electron/main/index.ts b/electron/main/index.ts
index 2c731fc..80b1eee 100644
--- a/electron/main/index.ts
+++ b/electron/main/index.ts
@@ -32,10 +32,6 @@ import { logger } from '../utils/logger';
 import { warmupNetworkOptimization } from '../utils/uv-env';
 import { resolvePythonRuntime, resolveUvRuntime } from '../utils/python-runtime';
 import { initTelemetry } from '../utils/telemetry';
-import {
-  getOrCreateAgentGatewaySessionClientId,
-  rotateAgentGatewaySessionClientId,
-} from '../utils/store';
 
 import { isQuitting, setQuitting } from './app-state';
 import { applyProxySettings } from './proxy';
@@ -456,12 +452,7 @@ async function initialize(): Promise<void> {
   });
   const imageWorkspace = localImageWorkspaceEnabled
     ? new LocalImageWorkspace({ userDataDir: app.getPath('userData') })
-    : new WorksSquareDesignWorkspace({
-        eventSessionClientIdStore: {
-          getOrCreate: getOrCreateAgentGatewaySessionClientId,
-          rotate: rotateAgentGatewaySessionClientId,
-        },
-      });
+    : new WorksSquareDesignWorkspace();
   imageWorkspaceModule = imageWorkspace;
   if (consumeWorksSquareStartupRuntimeCleanupRequired()) {
     await clearManagedWorksSquareRuntimeBestEffort({
diff --git a/shared/image-workspace.ts b/shared/image-workspace.ts
index 27fb7e1..8772654 100644
--- a/shared/image-workspace.ts
+++ b/shared/image-workspace.ts
@@ -47,14 +47,28 @@ export type DesignMessage = {
 export type DesignWorkspaceSummary = {
   workspaceId: string;
   title: string;
-  turnRevision: number;
   viewRevision: number;
+  conversationCount: number;
   phase: DesignWorkspacePhase;
-  brief: DesignBrief;
   updatedAt: string;
 };
 
 export type DesignWorkspace = DesignWorkspaceSummary & {
+  conversations: DesignConversationSummary[];
+};
+
+export type DesignConversationSummary = {
+  conversationId: string;
+  workspaceId: string;
+  title: string;
+  turnRevision: number;
+  phase: DesignWorkspacePhase;
+  brief: DesignBrief;
+  createdAt: string;
+  updatedAt: string;
+};
+
+export type DesignConversation = DesignConversationSummary & {
   messages: DesignMessage[];
 };
 
@@ -86,6 +100,7 @@ export type DesignAssetUploadInput = {
 export type DesignGenerationTask = {
   taskId: string;
   workspaceId: string;
+  conversationId: string | null;
   medium: DesignMedium;
   status: DesignTaskStatus;
   briefVersion: number;
@@ -106,12 +121,13 @@ export type DesignGenerationTaskUpdatedEvent = {
   generationTask: DesignGenerationTask;
 };
 
-export type DesignGenerationTasksSnapshotEvent = {
+export type DesignConversationSnapshotEvent = {
   id: string;
-  type: 'design.generation_tasks.snapshot';
+  type: 'design.conversation.snapshot';
   workspaceId: string;
+  conversationId: string;
   workspaceViewRevision: number;
-  workspace: DesignWorkspace;
+  conversation: DesignConversation;
   generationTasks: DesignGenerationTask[];
 };
 
@@ -119,6 +135,7 @@ export type DesignAssistantDeltaEvent = {
   id: string;
   type: 'design.assistant.delta';
   workspaceId: string;
+  conversationId: string;
   clientTurnId: string;
   turnRevision: number;
   chunkIndex: number;
@@ -127,7 +144,7 @@ export type DesignAssistantDeltaEvent = {
 
 export type DesignWorkspaceEvent =
   | DesignGenerationTaskUpdatedEvent
-  | DesignGenerationTasksSnapshotEvent
+  | DesignConversationSnapshotEvent
   | DesignAssistantDeltaEvent;
 
 export type DesignWorkspaceBootstrap = {
@@ -140,6 +157,12 @@ export type DesignCreateWorkspaceInput = {
   title: string;
 };
 
+export type DesignCreateConversationInput = {
+  workspaceId: string;
+  clientConversationId: string;
+  title: string;
+};
+
 export type DesignRenameWorkspaceInput = {
   workspaceId: string;
   title: string;
@@ -147,6 +170,7 @@ export type DesignRenameWorkspaceInput = {
 
 export type DesignSubmitMessageInput = {
   workspaceId: string;
+  conversationId: string;
   clientTurnId: string;
   expectedTurnRevision: number;
   message: string;
@@ -155,6 +179,7 @@ export type DesignSubmitMessageInput = {
 
 export type DesignConfirmGenerationInput = {
   workspaceId: string;
+  conversationId: string;
   clientTurnId: string;
   expectedTurnRevision: number;
   quoteId: string;
diff --git a/src/components/layout/ImageWorkspaceSidebar.tsx b/src/components/layout/ImageWorkspaceSidebar.tsx
index 2555cb6..3827dc4 100644
--- a/src/components/layout/ImageWorkspaceSidebar.tsx
+++ b/src/components/layout/ImageWorkspaceSidebar.tsx
@@ -2,12 +2,14 @@ import { useEffect, useState } from 'react';
 import {
   FolderKanban,
   Loader2,
+  MessageSquareText,
   Pencil,
   Plus,
   RefreshCw,
   X,
 } from 'lucide-react';
 import { useNavigate } from 'react-router-dom';
+import { toast } from 'sonner';
 import { Button } from '@/components/ui/button';
 import {
   Dialog,
@@ -36,11 +38,16 @@ export function ImageWorkspaceSidebar({ sidebarCollapsed }: ImageWorkspaceSideba
   const status = useImageWorkspaceStore((state) => state.status);
   const bootstrap = useImageWorkspaceStore((state) => state.bootstrap);
   const activeWorkspaceId = useImageWorkspaceStore((state) => state.activeWorkspaceId);
+  const activeConversationId = useImageWorkspaceStore((state) => state.activeConversationId);
+  const workspace = useImageWorkspaceStore((state) => state.workspace);
+  const creatingConversation = useImageWorkspaceStore((state) => state.creatingConversation);
   const workspaceError = useImageWorkspaceStore((state) => state.error);
   const load = useImageWorkspaceStore((state) => state.load);
   const createProject = useImageWorkspaceStore((state) => state.createProject);
+  const createConversation = useImageWorkspaceStore((state) => state.createConversation);
   const renameProject = useImageWorkspaceStore((state) => state.renameProject);
   const selectProject = useImageWorkspaceStore((state) => state.selectProject);
+  const selectConversation = useImageWorkspaceStore((state) => state.selectConversation);
   const [projectsOpen, setProjectsOpen] = useState(true);
   const [dialog, setDialog] = useState<ProjectDialogState | null>(null);
   const [projectName, setProjectName] = useState('');
@@ -107,6 +114,15 @@ export function ImageWorkspaceSidebar({ sidebarCollapsed }: ImageWorkspaceSideba
     navigate('/image-canvas');
   };
 
+  const handleCreateConversation = async () => {
+    try {
+      await createConversation();
+      navigate('/image-canvas');
+    } catch (error) {
+      toast.error(error instanceof Error ? error.message : String(error));
+    }
+  };
+
   return (
     <div data-testid="sidebar-image-workspace" className="min-h-0 space-y-1">
       <Button
@@ -207,7 +223,7 @@ export function ImageWorkspaceSidebar({ sidebarCollapsed }: ImageWorkspaceSideba
                       <span className="min-w-0 flex-1">
                         <span className="block truncate text-sm font-medium">{project.title}</span>
                         <span className="block truncate text-[10px] font-medium text-muted-foreground">
-                          {project.brief.summary}
+                          {project.conversationCount} 个会话
                         </span>
                       </span>
                     </button>
@@ -220,6 +236,58 @@ export function ImageWorkspaceSidebar({ sidebarCollapsed }: ImageWorkspaceSideba
                       <Pencil className="h-3.5 w-3.5" />
                     </button>
                   </div>
+                  {active ? (
+                    <div className="mt-1 border-t border-brand/15 pt-1.5">
+                      <div className="flex min-h-10 items-center justify-between gap-2 px-1">
+                        <span className="text-[10px] font-semibold text-muted-foreground">设计会话</span>
+                        <button
+                          type="button"
+                          aria-label="新建设计会话"
+                          title="新建设计会话"
+                          aria-busy={creatingConversation}
+                          className="flex h-10 w-10 shrink-0 items-center justify-center rounded-lg text-muted-foreground transition-[background-color,color,transform] hover:bg-background hover:text-brand active:scale-[0.96]"
+                          disabled={creatingConversation}
+                          onClick={() => void handleCreateConversation()}
+                        >
+                          {creatingConversation
+                            ? <Loader2 className="h-3.5 w-3.5 animate-spin" />
+                            : <Plus className="h-3.5 w-3.5" />}
+                        </button>
+                      </div>
+                      <div className="space-y-0.5 pb-1">
+                        {workspace?.workspaceId === project.workspaceId
+                          ? workspace.conversations.slice(0, 6).map((conversation) => {
+                              const selected = conversation.conversationId === activeConversationId;
+                              return (
+                                <button
+                                  key={conversation.conversationId}
+                                  type="button"
+                                  data-testid={`sidebar-image-conversation-${conversation.conversationId}`}
+                                  aria-current={selected ? 'page' : undefined}
+                                  className={cn(
+                                    'flex min-h-10 w-full items-center gap-2 rounded-lg px-2 text-left transition-[background-color,color,transform] active:scale-[0.96]',
+                                    selected
+                                      ? 'bg-background text-foreground shadow-soft'
+                                      : 'text-muted-foreground hover:bg-background/70 hover:text-foreground',
+                                  )}
+                                  onClick={() => void selectConversation(conversation.conversationId)}
+                                >
+                                  <MessageSquareText className="h-3.5 w-3.5 shrink-0" />
+                                  <span className="min-w-0 flex-1">
+                                    <span className="block truncate text-[11px] font-semibold">
+                                      {conversation.title}
+                                    </span>
+                                    <span className="block truncate text-[10px]">
+                                      {conversation.brief.summary}
+                                    </span>
+                                  </span>
+                                </button>
+                              );
+                            })
+                          : null}
+                      </div>
+                    </div>
+                  ) : null}
                 </section>
               );
             }) : null}
diff --git a/src/lib/image-workspace.ts b/src/lib/image-workspace.ts
index e33ab59..693bf33 100644
--- a/src/lib/image-workspace.ts
+++ b/src/lib/image-workspace.ts
@@ -12,6 +12,7 @@ import {
   designAssetDownloadPath,
   type DesignAsset,
   type DesignAssetSaveResult,
+  type DesignConversation,
   type DesignGenerationTask,
   type DesignWorkspace,
   type DesignWorkspaceBootstrap,
@@ -49,6 +50,10 @@ export function createImageWorkspaceTurnId(): string {
   return createClientId('turn');
 }
 
+export function createImageWorkspaceConversationId(): string {
+  return createClientId('conversation');
+}
+
 function getErrorStatus(error: unknown): number {
   if (error instanceof AppError && typeof error.details?.status === 'number') {
     return error.details.status;
@@ -123,15 +128,42 @@ export function fetchImageWorkspaceProject(workspaceId: string): Promise<DesignW
   );
 }
 
+export function createImageWorkspaceConversation(
+  workspaceId: string,
+  title = '新会话',
+  clientConversationId = createImageWorkspaceConversationId(),
+): Promise<DesignConversation> {
+  return requestData(
+    `${IMAGE_WORKSPACE_API_PATH}/workspaces/${encodeURIComponent(workspaceId)}/conversations`,
+    {
+      method: 'POST',
+      body: JSON.stringify({
+        clientConversationId,
+        title: title.trim(),
+      }),
+    },
+  );
+}
+
+export function fetchImageWorkspaceConversation(
+  workspaceId: string,
+  conversationId: string,
+): Promise<DesignConversation> {
+  return requestData(
+    `${IMAGE_WORKSPACE_API_PATH}/workspaces/${encodeURIComponent(workspaceId)}/conversations/${encodeURIComponent(conversationId)}`,
+  );
+}
+
 export function sendImageWorkspaceMessage(
   workspaceId: string,
+  conversationId: string,
   expectedTurnRevision: number,
   message: string,
   clientTurnId = createImageWorkspaceTurnId(),
   attachmentAssetIds: string[] = [],
-): Promise<DesignWorkspace> {
+): Promise<DesignConversation> {
   return requestData(
-    `${IMAGE_WORKSPACE_API_PATH}/workspaces/${encodeURIComponent(workspaceId)}/messages`,
+    `${IMAGE_WORKSPACE_API_PATH}/workspaces/${encodeURIComponent(workspaceId)}/conversations/${encodeURIComponent(conversationId)}/messages`,
     {
       method: 'POST',
       body: JSON.stringify({
@@ -146,12 +178,13 @@ export function sendImageWorkspaceMessage(
 
 export function confirmImageWorkspaceGeneration(
   workspaceId: string,
+  conversationId: string,
   expectedTurnRevision: number,
   quoteId: string,
   clientTurnId = createImageWorkspaceTurnId(),
-): Promise<DesignWorkspace> {
+): Promise<DesignConversation> {
   return requestData(
-    `${IMAGE_WORKSPACE_API_PATH}/workspaces/${encodeURIComponent(workspaceId)}/quotes/${encodeURIComponent(quoteId)}/confirm`,
+    `${IMAGE_WORKSPACE_API_PATH}/workspaces/${encodeURIComponent(workspaceId)}/conversations/${encodeURIComponent(conversationId)}/quotes/${encodeURIComponent(quoteId)}/confirm`,
     {
       method: 'POST',
       body: JSON.stringify({
@@ -170,10 +203,13 @@ export function fetchImageWorkspaceTasks(
   );
 }
 
-export async function openImageWorkspaceTaskEvents(workspaceId: string): Promise<EventSource> {
+export async function openImageWorkspaceTaskEvents(
+  workspaceId: string,
+  conversationId: string,
+): Promise<EventSource> {
   await ensureHostApiToken();
   return createHostEventSource(
-    `${IMAGE_WORKSPACE_API_PATH}/workspaces/${encodeURIComponent(workspaceId)}/events`,
+    `${IMAGE_WORKSPACE_API_PATH}/workspaces/${encodeURIComponent(workspaceId)}/conversations/${encodeURIComponent(conversationId)}/events`,
   );
 }
 
diff --git a/src/pages/ImageCanvas/index.tsx b/src/pages/ImageCanvas/index.tsx
index 52c4fd6..a733fd3 100644
--- a/src/pages/ImageCanvas/index.tsx
+++ b/src/pages/ImageCanvas/index.tsx
@@ -16,6 +16,7 @@ import {
   ImageIcon,
   Loader2,
   Maximize2,
+  MessageSquarePlus,
   Plus,
   RefreshCw,
   Send,
@@ -26,6 +27,7 @@ import {
 } from 'lucide-react';
 import { toast } from 'sonner';
 import { Button } from '@/components/ui/button';
+import { Select } from '@/components/ui/select';
 import {
   Dialog,
   DialogClose,
@@ -402,18 +404,24 @@ export function ImageCanvas() {
   const status = useImageWorkspaceStore((state) => state.status);
   const bootstrap = useImageWorkspaceStore((state) => state.bootstrap);
   const workspace = useImageWorkspaceStore((state) => state.workspace);
+  const conversation = useImageWorkspaceStore((state) => state.conversation);
+  const activeConversationId = useImageWorkspaceStore((state) => state.activeConversationId);
+  const creatingConversation = useImageWorkspaceStore((state) => state.creatingConversation);
   const tasks = useImageWorkspaceStore((state) => state.tasks);
   const pendingTurn = useImageWorkspaceStore((state) => state.pendingTurn);
   const workspaceError = useImageWorkspaceStore((state) => state.error);
   const load = useImageWorkspaceStore((state) => state.load);
   const refreshWorkspace = useImageWorkspaceStore((state) => state.refreshWorkspace);
+  const refreshConversation = useImageWorkspaceStore((state) => state.refreshConversation);
   const refreshTasks = useImageWorkspaceStore((state) => state.refreshTasks);
   const connectTaskStream = useImageWorkspaceStore((state) => state.connectTaskStream);
   const disconnectTaskStream = useImageWorkspaceStore((state) => state.disconnectTaskStream);
   const sendMessage = useImageWorkspaceStore((state) => state.sendMessage);
   const confirmGeneration = useImageWorkspaceStore((state) => state.confirmGeneration);
+  const createConversation = useImageWorkspaceStore((state) => state.createConversation);
+  const selectConversation = useImageWorkspaceStore((state) => state.selectConversation);
   const [prompt, setPrompt] = useState('');
-  const [submitting, setSubmitting] = useState(false);
+  const [submittingConversationId, setSubmittingConversationId] = useState<string | null>(null);
   const [confirmingQuoteId, setConfirmingQuoteId] = useState<string | null>(null);
   const [actionError, setActionError] = useState<string | null>(null);
   const [firstFramePickerOpen, setFirstFramePickerOpen] = useState(false);
@@ -423,8 +431,8 @@ export function ImageCanvas() {
   const conversationEndRef = useRef<HTMLDivElement | null>(null);
 
   const quote = useMemo(
-    () => workspace ? activeQuote(workspace.messages) : null,
-    [workspace],
+    () => conversation ? activeQuote(conversation.messages) : null,
+    [conversation],
   );
   const generationAvailable = bootstrap?.capabilities.generation ?? false;
   const firstFrameAssets = useMemo(
@@ -442,9 +450,11 @@ export function ImageCanvas() {
     [tasks, uploadedFirstFrameAsset, workspace?.workspaceId],
   );
   const conversationMessages = useMemo<RenderedDesignMessage[]>(() => {
-    if (!workspace) return [];
-    const messages: RenderedDesignMessage[] = [...workspace.messages];
-    if (!pendingTurn || pendingTurn.workspaceId !== workspace.workspaceId) return messages;
+    if (!conversation) return [];
+    const messages: RenderedDesignMessage[] = [...conversation.messages];
+    if (!pendingTurn
+      || pendingTurn.workspaceId !== conversation.workspaceId
+      || pendingTurn.conversationId !== conversation.conversationId) return messages;
     if (pendingTurn.userText) {
       messages.push({
         id: `${pendingTurn.clientTurnId}:user`,
@@ -469,8 +479,10 @@ export function ImageCanvas() {
       streaming: true,
     });
     return messages;
-  }, [pendingTurn, workspace]);
+  }, [conversation, pendingTurn]);
   const taskWorkspaceId = workspace?.workspaceId ?? null;
+  const taskConversationId = conversation?.conversationId ?? null;
+  const submitting = submittingConversationId === taskConversationId;
   const hasActiveTasks = tasks.some((task) => ACTIVE_TASK_STATUSES.has(task.status));
 
   useEffect(() => {
@@ -478,10 +490,18 @@ export function ImageCanvas() {
   }, [authenticated, load, status]);
 
   useEffect(() => {
-    if (!taskWorkspaceId) return;
+    if (!taskWorkspaceId || !taskConversationId) return;
     connectTaskStream();
     return disconnectTaskStream;
-  }, [connectTaskStream, disconnectTaskStream, taskWorkspaceId]);
+  }, [connectTaskStream, disconnectTaskStream, taskConversationId, taskWorkspaceId]);
+
+  useEffect(() => {
+    setPrompt('');
+    setActionError(null);
+    setConfirmingQuoteId(null);
+    setFirstFramePickerOpen(false);
+    setFirstFrameError(null);
+  }, [taskConversationId]);
 
   useEffect(() => {
     if (typeof conversationEndRef.current?.scrollIntoView === 'function') {
@@ -490,27 +510,30 @@ export function ImageCanvas() {
   }, [conversationMessages.length, pendingTurn?.assistantText]);
 
   const handleConfirm = async (quoteId: string) => {
-    if (!workspace || confirmingQuoteId) return;
+    if (!workspace || !conversation || confirmingQuoteId) return;
     if (!generationAvailable) {
       setActionError(CONFIRMATION_UNAVAILABLE_MESSAGE);
       return;
     }
     const requestedWorkspaceId = workspace.workspaceId;
+    const requestedConversationId = conversation.conversationId;
     setConfirmingQuoteId(quoteId);
     setActionError(null);
     try {
       await confirmGeneration(quoteId);
     } catch (error) {
-      if (useImageWorkspaceStore.getState().activeWorkspaceId !== requestedWorkspaceId) return;
+      const current = useImageWorkspaceStore.getState();
+      if (current.activeWorkspaceId !== requestedWorkspaceId
+        || current.activeConversationId !== requestedConversationId) return;
       setActionError(error instanceof Error ? error.message : String(error));
     } finally {
-      setConfirmingQuoteId(null);
+      setConfirmingQuoteId((current) => current === quoteId ? null : current);
     }
   };
 
   const handleSend = async (override?: string) => {
     const message = (override ?? prompt).trim();
-    if (!workspace || !message || submitting) return;
+    if (!workspace || !conversation || !message || submitting) return;
     if (isGenerationConfirmationIntent(message)) {
       setPrompt('');
       if (quote && generationAvailable) {
@@ -521,69 +544,85 @@ export function ImageCanvas() {
       return;
     }
     const requestedWorkspaceId = workspace.workspaceId;
-    setSubmitting(true);
+    const requestedConversationId = conversation.conversationId;
+    setSubmittingConversationId(requestedConversationId);
     setActionError(null);
     setPrompt('');
     try {
       await sendMessage(message);
     } catch (error) {
-      if (useImageWorkspaceStore.getState().activeWorkspaceId !== requestedWorkspaceId) return;
+      const current = useImageWorkspaceStore.getState();
+      if (current.activeWorkspaceId !== requestedWorkspaceId
+        || current.activeConversationId !== requestedConversationId) return;
       setPrompt((current) => current.trim() ? current : message);
       setActionError(error instanceof Error ? error.message : String(error));
     } finally {
-      setSubmitting(false);
+      setSubmittingConversationId((current) => (
+        current === requestedConversationId ? null : current
+      ));
     }
   };
 
   const handleComposerKeyDown = (event: KeyboardEvent<HTMLTextAreaElement>) => {
-    if ((event.metaKey || event.ctrlKey) && event.key === 'Enter') {
-      event.preventDefault();
-      void handleSend();
-    }
+    if (event.key !== 'Enter' || event.shiftKey || event.nativeEvent.isComposing) return;
+    event.preventDefault();
+    void handleSend();
   };
 
   const handleFirstFrameSelect = async (asset: DesignAsset) => {
-    if (!workspace || submitting || firstFrameBusyKey) return;
+    if (!workspace || !conversation || submitting || firstFrameBusyKey) return;
     const requestedWorkspaceId = workspace.workspaceId;
+    const requestedConversationId = conversation.conversationId;
     setFirstFrameBusyKey(asset.assetId);
     setFirstFrameError(null);
     setActionError(null);
-    setSubmitting(true);
+    setSubmittingConversationId(requestedConversationId);
     setFirstFramePickerOpen(false);
     try {
       await sendMessage('使用作品图片作为视频首帧', [asset.assetId]);
     } catch (error) {
-      if (useImageWorkspaceStore.getState().activeWorkspaceId === requestedWorkspaceId) {
+      const current = useImageWorkspaceStore.getState();
+      if (current.activeWorkspaceId === requestedWorkspaceId
+        && current.activeConversationId === requestedConversationId) {
         setActionError(error instanceof Error ? error.message : String(error));
       }
     } finally {
       setFirstFrameBusyKey(null);
-      setSubmitting(false);
+      setSubmittingConversationId((current) => (
+        current === requestedConversationId ? null : current
+      ));
     }
   };
 
   const handleFirstFrameUpload = async (event: ChangeEvent<HTMLInputElement>) => {
     const file = event.currentTarget.files?.[0];
     event.currentTarget.value = '';
-    if (!workspace || !file || submitting || firstFrameBusyKey) return;
+    if (!workspace || !conversation || !file || submitting || firstFrameBusyKey) return;
     const requestedWorkspaceId = workspace.workspaceId;
+    const requestedConversationId = conversation.conversationId;
     setFirstFrameBusyKey('upload');
     setFirstFrameError(null);
-    setSubmitting(true);
+    setSubmittingConversationId(requestedConversationId);
     try {
       const asset = await uploadImageWorkspaceAsset(requestedWorkspaceId, file);
       setUploadedFirstFrameAsset(asset);
       await sendMessage('使用上传的图片作为视频首帧', [asset.assetId]);
-      if (useImageWorkspaceStore.getState().activeWorkspaceId === requestedWorkspaceId) {
+      const current = useImageWorkspaceStore.getState();
+      if (current.activeWorkspaceId === requestedWorkspaceId
+        && current.activeConversationId === requestedConversationId) {
         setFirstFramePickerOpen(false);
       }
     } catch (error) {
-      if (useImageWorkspaceStore.getState().activeWorkspaceId === requestedWorkspaceId) {
+      const current = useImageWorkspaceStore.getState();
+      if (current.activeWorkspaceId === requestedWorkspaceId
+        && current.activeConversationId === requestedConversationId) {
         setFirstFrameError(error instanceof Error ? error.message : String(error));
       }
     } finally {
       setFirstFrameBusyKey(null);
-      setSubmitting(false);
+      setSubmittingConversationId((current) => (
+        current === requestedConversationId ? null : current
+      ));
     }
   };
 
@@ -643,7 +682,7 @@ export function ImageCanvas() {
     );
   }
 
-  if (!workspace) {
+  if (!workspace || !conversation) {
     return (
       <div data-testid="image-canvas-page" className="-m-5 flex min-h-full items-center justify-center bg-background p-6 text-foreground sm:-m-6">
         <Loader2 role="status" className="h-6 w-6 animate-spin text-brand" />
@@ -668,25 +707,66 @@ export function ImageCanvas() {
             <p className="mt-0.5 flex min-w-0 items-center gap-1.5 text-xs font-medium text-muted-foreground">
               <Bot className="h-3.5 w-3.5 shrink-0" />
               <span className="truncate">
-                {workspace.brief.ready ? workspace.brief.summary : '设计 Agent 正在与你确认创作方向'}
+                {conversation.title} · {conversation.brief.ready
+                  ? conversation.brief.summary
+                  : '设计 Agent 正在与你确认创作方向'}
               </span>
             </p>
           </div>
         </div>
-        <Button
-          type="button"
-          variant="ghost"
-          size="icon"
-          aria-label="刷新设计项目"
-          className="h-9 w-9 rounded-full"
-          onClick={() => {
-            void refreshWorkspace()
-              .then(() => refreshTasks())
-              .catch(() => undefined);
-          }}
-        >
-          <RefreshCw className="h-4 w-4" />
-        </Button>
+        <div className="flex min-w-0 items-center gap-1.5">
+          <Select
+            aria-label="切换设计会话"
+            data-testid="image-canvas-conversation-select"
+            className="h-10 w-36 max-w-[34vw] rounded-xl py-1.5 text-xs font-semibold sm:w-48"
+            value={activeConversationId ?? ''}
+            disabled={creatingConversation}
+            onChange={(event) => {
+              void selectConversation(event.currentTarget.value).catch((error) => {
+                setActionError(error instanceof Error ? error.message : String(error));
+              });
+            }}
+          >
+            {workspace.conversations.map((item) => (
+              <option key={item.conversationId} value={item.conversationId}>
+                {item.title}
+              </option>
+            ))}
+          </Select>
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            aria-label="新建设计会话"
+            aria-busy={creatingConversation}
+            className="h-10 w-10 rounded-full transition-transform active:scale-[0.96]"
+            disabled={creatingConversation}
+            onClick={() => {
+              void createConversation().catch((error) => {
+                setActionError(error instanceof Error ? error.message : String(error));
+              });
+            }}
+          >
+            {creatingConversation
+              ? <Loader2 className="h-4 w-4 animate-spin" />
+              : <MessageSquarePlus className="h-4 w-4" />}
+          </Button>
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            aria-label="刷新设计项目"
+            className="h-10 w-10 rounded-full transition-transform active:scale-[0.96]"
+            onClick={() => {
+              void refreshWorkspace()
+                .then(() => refreshConversation())
+                .then(() => refreshTasks())
+                .catch(() => undefined);
+            }}
+          >
+            <RefreshCw className="h-4 w-4" />
+          </Button>
+        </div>
       </header>
 
       <div className="flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden lg:flex-row">
@@ -819,7 +899,7 @@ export function ImageCanvas() {
                 />
                 {actionError ? <p role="alert" className="mt-2 rounded-xl bg-destructive/10 px-3 py-2 text-xs font-semibold text-destructive">{actionError}</p> : null}
                 <div className="mt-2 flex items-center justify-between gap-3 border-t border-border/70 pt-2">
-                  <span className="text-[10px] font-medium text-muted-foreground">⌘/Ctrl + Enter 发送</span>
+                  <span className="text-[10px] font-medium text-muted-foreground">Enter 发送 · Shift+Enter 换行</span>
                   <Button type="submit" className="h-9 rounded-full bg-brand px-4 text-primary-foreground" disabled={submitting || !prompt.trim()}>
                     {submitting ? <Loader2 className="mr-2 h-4 w-4 animate-spin" /> : <Send className="mr-2 h-4 w-4" />}
                     发送给设计 Agent
diff --git a/src/stores/image-workspace.ts b/src/stores/image-workspace.ts
index 2392167..07044f4 100644
--- a/src/stores/image-workspace.ts
+++ b/src/stores/image-workspace.ts
@@ -1,9 +1,11 @@
 import { create } from 'zustand';
 import {
   confirmImageWorkspaceGeneration,
+  createImageWorkspaceConversation,
   createImageWorkspaceTurnId,
   createImageWorkspaceProject,
   fetchImageWorkspace,
+  fetchImageWorkspaceConversation,
   fetchImageWorkspaceProject,
   fetchImageWorkspaceTasks,
   ImageWorkspaceApiError,
@@ -15,8 +17,9 @@ import { useAuthStore } from '@/stores/auth';
 import {
   IMAGE_WORKSPACE_UNAVAILABLE_CODE,
   type DesignAssistantDeltaEvent,
+  type DesignConversation,
+  type DesignConversationSnapshotEvent,
   type DesignGenerationTask,
-  type DesignGenerationTasksSnapshotEvent,
   type DesignGenerationTaskUpdatedEvent,
   type DesignWorkspace,
   type DesignWorkspaceBootstrap,
@@ -35,6 +38,7 @@ export type ImageWorkspaceTaskStreamState = 'idle' | 'connecting' | 'connected'
 
 export type PendingDesignTurn = {
   workspaceId: string;
+  conversationId: string;
   clientTurnId: string;
   turnRevision: number;
   userText: string | null;
@@ -47,21 +51,27 @@ type ImageWorkspaceState = {
   status: ImageWorkspaceLoadStatus;
   bootstrap: DesignWorkspaceBootstrap | null;
   activeWorkspaceId: string | null;
+  activeConversationId: string | null;
   workspace: DesignWorkspace | null;
+  conversation: DesignConversation | null;
+  creatingConversation: boolean;
   tasks: DesignGenerationTask[];
   pendingTurn: PendingDesignTurn | null;
   taskStreamState: ImageWorkspaceTaskStreamState;
   error: string | null;
   load: () => Promise<DesignWorkspaceBootstrap | null>;
   createProject: (title: string) => Promise<DesignWorkspace>;
+  createConversation: (title?: string) => Promise<DesignConversation>;
   renameProject: (workspaceId: string, title: string) => Promise<DesignWorkspace>;
   selectProject: (workspaceId: string) => Promise<void>;
+  selectConversation: (conversationId: string) => Promise<void>;
   refreshWorkspace: () => Promise<DesignWorkspace | null>;
+  refreshConversation: () => Promise<DesignConversation | null>;
   refreshTasks: () => Promise<DesignGenerationTask[]>;
   connectTaskStream: () => void;
   disconnectTaskStream: () => void;
-  sendMessage: (message: string, attachmentAssetIds?: string[]) => Promise<DesignWorkspace>;
-  confirmGeneration: (quoteId: string) => Promise<DesignWorkspace>;
+  sendMessage: (message: string, attachmentAssetIds?: string[]) => Promise<DesignConversation>;
+  confirmGeneration: (quoteId: string) => Promise<DesignConversation>;
   reset: () => void;
 };
 
@@ -71,9 +81,12 @@ const CONFIRMED_TASK_RECONCILE_ATTEMPTS = 5;
 const CONFIRMED_TASK_RECONCILE_INTERVAL_MS = 250;
 let activeTaskEventSource: EventSource | null = null;
 let activeTaskEventWorkspaceId: string | null = null;
+let activeTaskEventConversationId: string | null = null;
 let taskStreamGeneration = 0;
 let taskFallbackTimer: ReturnType<typeof setInterval> | null = null;
 const taskEventRevisions = new Map<string, number>();
+let workspaceLoadGeneration = 0;
+let conversationSelectionGeneration = 0;
 
 function taskRevisionKey(workspaceId: string, taskId: string): string {
   return `${workspaceId}:${taskId}`;
@@ -94,6 +107,7 @@ function closeTaskEventSource(): void {
   }
   activeTaskEventSource = null;
   activeTaskEventWorkspaceId = null;
+  activeTaskEventConversationId = null;
   taskEventRevisions.clear();
 }
 
@@ -117,26 +131,27 @@ function parseTaskUpdatedEvent(event: Event): DesignGenerationTaskUpdatedEvent |
   }
 }
 
-function parseTasksSnapshotEvent(event: Event): DesignGenerationTasksSnapshotEvent | null {
+function parseConversationSnapshotEvent(event: Event): DesignConversationSnapshotEvent | null {
   const data = (event as MessageEvent<unknown>).data;
   if (typeof data !== 'string') return null;
   try {
-    const payload = JSON.parse(data) as Partial<DesignGenerationTasksSnapshotEvent>;
-    if (payload.type !== 'design.generation_tasks.snapshot'
+    const payload = JSON.parse(data) as Partial<DesignConversationSnapshotEvent>;
+    if (payload.type !== 'design.conversation.snapshot'
       || typeof payload.id !== 'string'
       || typeof payload.workspaceId !== 'string'
+      || typeof payload.conversationId !== 'string'
       || !Number.isInteger(payload.workspaceViewRevision)
-      || !payload.workspace
-      || payload.workspace.workspaceId !== payload.workspaceId
-      || payload.workspace.viewRevision !== payload.workspaceViewRevision
-      || !Array.isArray(payload.workspace.messages)
+      || !payload.conversation
+      || payload.conversation.workspaceId !== payload.workspaceId
+      || payload.conversation.conversationId !== payload.conversationId
+      || !Array.isArray(payload.conversation.messages)
       || !Array.isArray(payload.generationTasks)
       || !payload.generationTasks.every((task) => (
         typeof task?.taskId === 'string' && task.workspaceId === payload.workspaceId
       ))) {
       return null;
     }
-    return payload as DesignGenerationTasksSnapshotEvent;
+    return payload as DesignConversationSnapshotEvent;
   } catch {
     return null;
   }
@@ -150,6 +165,7 @@ function parseAssistantDeltaEvent(event: Event): DesignAssistantDeltaEvent | nul
     if (payload.type !== 'design.assistant.delta'
       || typeof payload.id !== 'string'
       || typeof payload.workspaceId !== 'string'
+      || typeof payload.conversationId !== 'string'
       || typeof payload.clientTurnId !== 'string'
       || !Number.isInteger(payload.turnRevision)
       || Number(payload.turnRevision) < 1
@@ -198,7 +214,7 @@ function messageOf(error: unknown): string {
 }
 
 function toSummary(workspace: DesignWorkspace): DesignWorkspaceSummary {
-  const { messages: _messages, ...summary } = workspace;
+  const { conversations: _conversations, ...summary } = workspace;
   return summary;
 }
 
@@ -217,15 +233,32 @@ function upsertSummary(
   };
 }
 
+function upsertConversation(
+  workspace: DesignWorkspace | null,
+  conversation: DesignConversation,
+): DesignWorkspace | null {
+  if (!workspace || workspace.workspaceId !== conversation.workspaceId) return workspace;
+  const conversations = workspace.conversations.filter(
+    (item) => item.conversationId !== conversation.conversationId,
+  );
+  const { messages: _messages, ...summary } = conversation;
+  return {
+    ...workspace,
+    conversationCount: Math.max(workspace.conversationCount, conversations.length + 1),
+    conversations: [summary, ...conversations],
+  };
+}
+
 function createPendingTurn(
-  workspace: DesignWorkspace,
+  conversation: DesignConversation,
   clientTurnId: string,
   userText: string,
 ): PendingDesignTurn {
   return {
-    workspaceId: workspace.workspaceId,
+    workspaceId: conversation.workspaceId,
+    conversationId: conversation.conversationId,
     clientTurnId,
-    turnRevision: workspace.turnRevision + 1,
+    turnRevision: conversation.turnRevision + 1,
     userText,
     assistantText: '',
     lastChunkIndex: -1,
@@ -245,29 +278,37 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
       if (get().taskStreamState !== 'degraded' || !get().activeWorkspaceId) return;
       void get().refreshWorkspace()
         .catch(() => null)
+        .then(() => get().refreshConversation().catch(() => null))
         .then(() => get().refreshTasks().catch(() => []));
     }, TASK_FALLBACK_POLL_INTERVAL_MS);
   };
 
-  const startTaskStream = (workspaceId: string) => {
+  const startTaskStream = (workspaceId: string, conversationId: string) => {
     if (activeTaskEventWorkspaceId === workspaceId
+      && activeTaskEventConversationId === conversationId
       && get().taskStreamState !== 'idle') return;
     closeTaskEventSource();
     const generation = taskStreamGeneration;
     activeTaskEventWorkspaceId = workspaceId;
+    activeTaskEventConversationId = conversationId;
     set({ taskStreamState: 'connecting' });
-    void openImageWorkspaceTaskEvents(workspaceId).then((source) => {
-      if (generation !== taskStreamGeneration || get().activeWorkspaceId !== workspaceId) {
+    void openImageWorkspaceTaskEvents(workspaceId, conversationId).then((source) => {
+      if (generation !== taskStreamGeneration
+        || get().activeWorkspaceId !== workspaceId
+        || get().activeConversationId !== conversationId) {
         source.close();
         return;
       }
       activeTaskEventSource = source;
       source.addEventListener('design.assistant.delta', (event) => {
         const delta = parseAssistantDeltaEvent(event);
-        if (!delta || delta.workspaceId !== activeTaskEventWorkspaceId) return;
+        if (!delta
+          || delta.workspaceId !== activeTaskEventWorkspaceId
+          || delta.conversationId !== activeTaskEventConversationId) return;
         set((state) => {
           if (state.activeWorkspaceId !== delta.workspaceId
-            || (state.workspace?.turnRevision ?? 0) >= delta.turnRevision) {
+            || state.activeConversationId !== delta.conversationId
+            || (state.conversation?.turnRevision ?? 0) >= delta.turnRevision) {
             return state;
           }
           const pending = state.pendingTurn;
@@ -276,6 +317,7 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
             return {
               pendingTurn: {
                 workspaceId: delta.workspaceId,
+                conversationId: delta.conversationId,
                 clientTurnId: delta.clientTurnId,
                 turnRevision: delta.turnRevision,
                 userText: null,
@@ -286,6 +328,7 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
             };
           }
           if (pending.workspaceId !== delta.workspaceId
+            || pending.conversationId !== delta.conversationId
             || pending.clientTurnId !== delta.clientTurnId
             || pending.turnRevision !== delta.turnRevision
             || delta.chunkIndex !== pending.lastChunkIndex + 1) {
@@ -300,11 +343,14 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
           };
         });
       });
-      source.addEventListener('design.generation_tasks.snapshot', (event) => {
-        const snapshot = parseTasksSnapshotEvent(event);
-        if (!snapshot || snapshot.workspaceId !== activeTaskEventWorkspaceId) return;
+      source.addEventListener('design.conversation.snapshot', (event) => {
+        const snapshot = parseConversationSnapshotEvent(event);
+        if (!snapshot
+          || snapshot.workspaceId !== activeTaskEventWorkspaceId
+          || snapshot.conversationId !== activeTaskEventConversationId) return;
         set((state) => {
-          if (state.activeWorkspaceId !== snapshot.workspaceId) return state;
+          if (state.activeWorkspaceId !== snapshot.workspaceId
+            || state.activeConversationId !== snapshot.conversationId) return state;
           const tasksById = new Map(state.tasks.map((task) => [task.taskId, task]));
           for (const task of snapshot.generationTasks) {
             const key = taskRevisionKey(snapshot.workspaceId, task.taskId);
@@ -319,33 +365,34 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
               Math.max(knownRevision, snapshot.workspaceViewRevision),
             );
           }
-          const currentWorkspace = state.workspace?.workspaceId === snapshot.workspaceId
-            ? state.workspace
-            : null;
-          let workspace = state.workspace;
-          if (!currentWorkspace
-            || snapshot.workspaceViewRevision >= currentWorkspace.viewRevision) {
-            workspace = snapshot.workspace;
-          } else if (snapshot.workspace.turnRevision > currentWorkspace.turnRevision) {
-            workspace = {
-              ...snapshot.workspace,
-              title: currentWorkspace.title,
-              viewRevision: currentWorkspace.viewRevision,
-              updatedAt: currentWorkspace.updatedAt > snapshot.workspace.updatedAt
-                ? currentWorkspace.updatedAt
-                : snapshot.workspace.updatedAt,
-            };
-          }
+          const conversation = !state.conversation
+            || snapshot.conversation.turnRevision >= state.conversation.turnRevision
+            ? snapshot.conversation
+            : state.conversation;
+          const workspace = upsertConversation(
+            state.workspace
+              ? {
+                  ...state.workspace,
+                  viewRevision: Math.max(
+                    state.workspace.viewRevision,
+                    snapshot.workspaceViewRevision,
+                  ),
+                }
+              : null,
+            conversation,
+          );
           const bootstrap = workspace?.workspaceId === snapshot.workspaceId
             ? upsertSummary(state.bootstrap, workspace)
             : state.bootstrap;
           const pendingTurn = state.pendingTurn?.workspaceId === snapshot.workspaceId
-            && snapshot.workspace.turnRevision >= state.pendingTurn.turnRevision
+            && state.pendingTurn.conversationId === snapshot.conversationId
+            && snapshot.conversation.turnRevision >= state.pendingTurn.turnRevision
             ? null
             : state.pendingTurn;
           return {
             tasks: sortTasks([...tasksById.values()]),
             workspace,
+            conversation,
             bootstrap,
             pendingTurn,
           };
@@ -407,7 +454,9 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
         startFallbackPolling();
       };
     }).catch(() => {
-      if (generation !== taskStreamGeneration || get().activeWorkspaceId !== workspaceId) return;
+      if (generation !== taskStreamGeneration
+        || get().activeWorkspaceId !== workspaceId
+        || get().activeConversationId !== conversationId) return;
       set({ taskStreamState: 'degraded' });
       startFallbackPolling();
     });
@@ -422,7 +471,10 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
         status: 'auth-required',
         bootstrap: null,
         activeWorkspaceId: null,
+        activeConversationId: null,
         workspace: null,
+        conversation: null,
+        creatingConversation: false,
         tasks: [],
         pendingTurn: null,
         taskStreamState: 'idle',
@@ -434,49 +486,88 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
 
   const applyWorkspace = (workspace: DesignWorkspace): DesignWorkspace => {
     set((state) => {
-      const pendingTurn = state.pendingTurn?.workspaceId === workspace.workspaceId
-        && workspace.turnRevision >= state.pendingTurn.turnRevision
-        ? null
-        : state.pendingTurn;
       return {
         status: 'ready',
         bootstrap: upsertSummary(state.bootstrap, workspace),
         activeWorkspaceId: workspace.workspaceId,
         workspace,
-        pendingTurn,
         error: null,
       };
     });
     return workspace;
   };
 
+  const applyConversation = (conversation: DesignConversation): DesignConversation => {
+    let applied = conversation;
+    set((state) => {
+      if (state.conversation?.conversationId === conversation.conversationId
+        && (state.conversation.turnRevision > conversation.turnRevision
+          || (state.conversation.turnRevision === conversation.turnRevision
+            && state.conversation.updatedAt > conversation.updatedAt))) {
+        applied = state.conversation;
+        return state;
+      }
+      const pendingTurn = state.pendingTurn?.workspaceId === conversation.workspaceId
+        && state.pendingTurn.conversationId === conversation.conversationId
+        && conversation.turnRevision >= state.pendingTurn.turnRevision
+        ? null
+        : state.pendingTurn;
+      return {
+        workspace: upsertConversation(state.workspace, conversation),
+        activeConversationId: conversation.conversationId,
+        conversation,
+        pendingTurn,
+        error: null,
+      };
+    });
+    return applied;
+  };
+
   const loadWorkspace = async (workspaceId: string): Promise<void> => {
+    const loadGeneration = ++workspaceLoadGeneration;
+    conversationSelectionGeneration += 1;
     const workspace = await fetchImageWorkspaceProject(workspaceId);
-    if (get().activeWorkspaceId !== workspaceId) return;
+    if (loadGeneration !== workspaceLoadGeneration
+      || get().activeWorkspaceId !== workspaceId) return;
+    const currentConversationId = get().activeConversationId;
+    const conversationId = workspace.conversations.some(
+      (item) => item.conversationId === currentConversationId,
+    )
+      ? currentConversationId
+      : workspace.conversations[0]?.conversationId ?? null;
     const tasks = await fetchImageWorkspaceTasks(workspaceId);
-    if (get().activeWorkspaceId !== workspaceId) return;
+    if (loadGeneration !== workspaceLoadGeneration
+      || get().activeWorkspaceId !== workspaceId) return;
     set((state) => ({
       status: 'ready',
       bootstrap: upsertSummary(state.bootstrap, workspace),
       activeWorkspaceId: workspaceId,
+      activeConversationId: conversationId,
       workspace,
+      conversation: null,
       tasks: sortTasks(tasks),
       error: null,
     }));
-    startTaskStream(workspaceId);
-    for (const task of tasks) {
-      taskEventRevisions.set(taskRevisionKey(workspaceId, task.taskId), workspace.viewRevision);
-    }
+    if (!conversationId) return;
+    const selectionGeneration = ++conversationSelectionGeneration;
+    const conversation = await fetchImageWorkspaceConversation(workspaceId, conversationId);
+    if (loadGeneration !== workspaceLoadGeneration
+      || selectionGeneration !== conversationSelectionGeneration
+      || get().activeWorkspaceId !== workspaceId
+      || get().activeConversationId !== conversationId) return;
+    applyConversation(conversation);
+    startTaskStream(workspaceId, conversationId);
   };
 
   const recoverRevisionConflict = async (error: unknown): Promise<never> => {
     if (error instanceof ImageWorkspaceApiError
-      && error.code === 'workspace_revision_conflict') {
-      await get().refreshWorkspace().catch(() => null);
+      && (error.code === 'conversation_revision_conflict'
+        || error.code === 'workspace_revision_conflict')) {
+      await get().refreshConversation().catch(() => null);
       throw new ImageWorkspaceApiError(
         409,
         error.code,
-        '设计项目已更新，内容已刷新，请重新提交',
+        '设计会话已更新，内容已刷新，请重新提交',
       );
     }
     throw error;
@@ -486,7 +577,10 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
     status: 'idle',
     bootstrap: null,
     activeWorkspaceId: null,
+    activeConversationId: null,
     workspace: null,
+    conversation: null,
+    creatingConversation: false,
     tasks: [],
     pendingTurn: null,
     taskStreamState: 'idle',
@@ -509,7 +603,9 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
             status: 'ready',
             bootstrap,
             activeWorkspaceId,
+            activeConversationId: null,
             workspace: null,
+            conversation: null,
             tasks: [],
             pendingTurn: null,
             taskStreamState: 'idle',
@@ -525,7 +621,9 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
               status: unavailable(error) ? 'unavailable' : 'error',
               bootstrap: null,
               activeWorkspaceId: null,
+              activeConversationId: null,
               workspace: null,
+              conversation: null,
               tasks: [],
               pendingTurn: null,
               taskStreamState: 'idle',
@@ -543,8 +641,26 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
     createProject: async (title) => {
       try {
         const workspace = applyWorkspace(await createImageWorkspaceProject(title));
-        set({ tasks: [], pendingTurn: null });
-        startTaskStream(workspace.workspaceId);
+        const conversationId = workspace.conversations[0]?.conversationId ?? null;
+        set({
+          activeConversationId: conversationId,
+          conversation: null,
+          tasks: [],
+          pendingTurn: null,
+        });
+        if (conversationId) {
+          const selectionGeneration = ++conversationSelectionGeneration;
+          const conversation = await fetchImageWorkspaceConversation(
+            workspace.workspaceId,
+            conversationId,
+          );
+          if (selectionGeneration === conversationSelectionGeneration
+            && get().activeWorkspaceId === workspace.workspaceId
+            && get().activeConversationId === conversationId) {
+            applyConversation(conversation);
+            startTaskStream(workspace.workspaceId, conversationId);
+          }
+        }
         return workspace;
       } catch (error) {
         set({ error: handleRequestError(error) });
@@ -552,6 +668,37 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
       }
     },
 
+    createConversation: async (title = '新会话') => {
+      if (get().creatingConversation) {
+        throw new Error('正在创建新会话，请稍候');
+      }
+      const workspaceId = get().activeWorkspaceId;
+      if (!workspaceId) throw new Error('请先选择设计项目');
+      set({ creatingConversation: true });
+      try {
+        const conversation = await createImageWorkspaceConversation(workspaceId, title);
+        if (get().activeWorkspaceId !== workspaceId) return conversation;
+        conversationSelectionGeneration += 1;
+        stopTaskStream();
+        set({
+          activeConversationId: conversation.conversationId,
+          conversation: null,
+          pendingTurn: null,
+          taskStreamState: 'idle',
+          error: null,
+        });
+        applyConversation(conversation);
+        startTaskStream(workspaceId, conversation.conversationId);
+        void get().refreshWorkspace().catch(() => null);
+        return conversation;
+      } catch (error) {
+        set({ error: handleRequestError(error) });
+        throw error;
+      } finally {
+        set({ creatingConversation: false });
+      }
+    },
+
     renameProject: async (workspaceId, title) => {
       try {
         return applyWorkspace(await renameImageWorkspaceProject(workspaceId, title));
@@ -566,16 +713,56 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
       stopTaskStream();
       set({
         activeWorkspaceId: workspaceId,
+        activeConversationId: null,
         workspace: null,
+        conversation: null,
+        creatingConversation: false,
         tasks: [],
         pendingTurn: null,
         taskStreamState: 'idle',
         error: null,
       });
+      const loadPromise = loadWorkspace(workspaceId);
+      const loadGeneration = workspaceLoadGeneration;
       try {
-        await loadWorkspace(workspaceId);
+        await loadPromise;
       } catch (error) {
-        set({ error: handleRequestError(error) });
+        if (loadGeneration === workspaceLoadGeneration
+          && get().activeWorkspaceId === workspaceId) {
+          set({ error: handleRequestError(error) });
+        }
+      }
+    },
+
+    selectConversation: async (conversationId) => {
+      const state = get();
+      const workspaceId = state.activeWorkspaceId;
+      if (!workspaceId
+        || !state.workspace?.conversations.some(
+          (item) => item.conversationId === conversationId,
+        )) return;
+      const selectionGeneration = ++conversationSelectionGeneration;
+      stopTaskStream();
+      set({
+        activeConversationId: conversationId,
+        conversation: null,
+        pendingTurn: null,
+        taskStreamState: 'idle',
+        error: null,
+      });
+      try {
+        const conversation = await fetchImageWorkspaceConversation(workspaceId, conversationId);
+        if (selectionGeneration !== conversationSelectionGeneration
+          || get().activeWorkspaceId !== workspaceId
+          || get().activeConversationId !== conversationId) return;
+        applyConversation(conversation);
+        startTaskStream(workspaceId, conversationId);
+      } catch (error) {
+        if (selectionGeneration === conversationSelectionGeneration
+          && get().activeWorkspaceId === workspaceId
+          && get().activeConversationId === conversationId) {
+          set({ error: handleRequestError(error) });
+        }
       }
     },
 
@@ -597,6 +784,26 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
       }
     },
 
+    refreshConversation: async () => {
+      const workspaceId = get().activeWorkspaceId;
+      const conversationId = get().activeConversationId;
+      if (!workspaceId || !conversationId) return null;
+      try {
+        const refreshed = await fetchImageWorkspaceConversation(workspaceId, conversationId);
+        if (get().activeWorkspaceId !== workspaceId
+          || get().activeConversationId !== conversationId) return null;
+        const current = get().conversation;
+        if (current?.conversationId === conversationId
+          && current.turnRevision > refreshed.turnRevision) {
+          return current;
+        }
+        return applyConversation(refreshed);
+      } catch (error) {
+        set({ error: handleRequestError(error) });
+        throw error;
+      }
+    },
+
     refreshTasks: async () => {
       const workspaceId = get().activeWorkspaceId;
       if (!workspaceId) {
@@ -613,13 +820,6 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
           && currentWorkspace?.workspaceId === workspaceId
           && currentWorkspace.viewRevision === requestedViewRevision) {
           set((state) => ({ tasks: mergeTasks(state.tasks, tasks) }));
-          for (const task of tasks) {
-            const key = taskRevisionKey(workspaceId, task.taskId);
-            taskEventRevisions.set(
-              key,
-              Math.max(taskEventRevisions.get(key) ?? 0, requestedViewRevision),
-            );
-          }
         }
         return tasks;
       } catch (error) {
@@ -630,39 +830,48 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
 
     connectTaskStream: () => {
       const workspaceId = get().activeWorkspaceId;
-      if (workspaceId) startTaskStream(workspaceId);
+      const conversationId = get().activeConversationId;
+      if (workspaceId && conversationId) startTaskStream(workspaceId, conversationId);
     },
 
     disconnectTaskStream: stopTaskStream,
 
     sendMessage: async (message, attachmentAssetIds = []) => {
       const workspace = get().workspace;
+      const conversation = get().conversation;
       const userText = message.trim();
       const clientTurnId = createImageWorkspaceTurnId();
-      if (!workspace) throw new Error('请先选择设计项目');
+      if (!workspace || !conversation) throw new Error('请先选择设计会话');
       try {
-        set({ pendingTurn: createPendingTurn(workspace, clientTurnId, userText), error: null });
+        set({
+          pendingTurn: createPendingTurn(conversation, clientTurnId, userText),
+          error: null,
+        });
         const updated = attachmentAssetIds.length > 0
           ? await sendImageWorkspaceMessage(
               workspace.workspaceId,
-              workspace.turnRevision,
+              conversation.conversationId,
+              conversation.turnRevision,
               userText,
               clientTurnId,
               attachmentAssetIds,
             )
           : await sendImageWorkspaceMessage(
               workspace.workspaceId,
-              workspace.turnRevision,
+              conversation.conversationId,
+              conversation.turnRevision,
               userText,
               clientTurnId,
             );
-        if (get().activeWorkspaceId === workspace.workspaceId) {
-          applyWorkspace(updated);
+        if (get().activeWorkspaceId === workspace.workspaceId
+          && get().activeConversationId === conversation.conversationId) {
+          applyConversation(updated);
           await get().refreshTasks().catch(() => []);
         }
         return updated;
       } catch (error) {
-        if (get().activeWorkspaceId !== workspace.workspaceId) throw error;
+        if (get().activeWorkspaceId !== workspace.workspaceId
+          || get().activeConversationId !== conversation.conversationId) throw error;
         const errorMessage = handleRequestError(error);
         set((state) => ({
           error: errorMessage,
@@ -676,21 +885,25 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
 
     confirmGeneration: async (quoteId) => {
       const workspace = get().workspace;
-      if (!workspace) throw new Error('请先选择设计项目');
+      const conversation = get().conversation;
+      if (!workspace || !conversation) throw new Error('请先选择设计会话');
       const clientTurnId = createImageWorkspaceTurnId();
       try {
         set({
-          pendingTurn: createPendingTurn(workspace, clientTurnId, '确认生成'),
+          pendingTurn: createPendingTurn(conversation, clientTurnId, '确认生成'),
           error: null,
         });
         const updated = await confirmImageWorkspaceGeneration(
           workspace.workspaceId,
-          workspace.turnRevision,
+          conversation.conversationId,
+          conversation.turnRevision,
           quoteId,
           clientTurnId,
         );
         if (get().activeWorkspaceId === workspace.workspaceId) {
-          applyWorkspace(updated);
+          if (get().activeConversationId === conversation.conversationId) {
+            applyConversation(updated);
+          }
           let confirmedTaskVisible = get().tasks.some((task) => task.quoteId === quoteId);
           for (
             let attempt = 0;
@@ -718,7 +931,8 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
         }
         return updated;
       } catch (error) {
-        if (get().activeWorkspaceId !== workspace.workspaceId) throw error;
+        if (get().activeWorkspaceId !== workspace.workspaceId
+          || get().activeConversationId !== conversation.conversationId) throw error;
         const errorMessage = handleRequestError(error);
         set((state) => ({
           error: errorMessage,
@@ -732,12 +946,17 @@ export const useImageWorkspaceStore = create<ImageWorkspaceState>((set, get) =>
 
     reset: () => {
       inFlightLoad = null;
+      workspaceLoadGeneration += 1;
+      conversationSelectionGeneration += 1;
       closeTaskEventSource();
       set({
         status: 'idle',
         bootstrap: null,
         activeWorkspaceId: null,
+        activeConversationId: null,
         workspace: null,
+        conversation: null,
+        creatingConversation: false,
         tasks: [],
         pendingTurn: null,
         taskStreamState: 'idle',
diff --git a/tests/e2e/fixtures/electron.ts b/tests/e2e/fixtures/electron.ts
index 5ada531..2a85f63 100644
--- a/tests/e2e/fixtures/electron.ts
+++ b/tests/e2e/fixtures/electron.ts
@@ -12,6 +12,7 @@ import { tmpdir } from 'node:os';
 import { basename, join, resolve } from 'node:path';
 
 export type LaunchElectronOptions = {
+  imageWorkspaceMode?: 'local';
   skipSetup?: boolean;
 };
 
@@ -79,6 +80,7 @@ function buildElectronEnvironment(
   resources: ElectronTestResources,
   skipSetup: boolean,
   hostApiPort: number,
+  imageWorkspaceMode?: 'local',
 ): Record<string, string> {
   const env: Record<string, string> = {};
   for (const key of PASSTHROUGH_ENVIRONMENT_KEYS) {
@@ -103,6 +105,9 @@ function buildElectronEnvironment(
   if (skipSetup) {
     env.NIANCODE_E2E_SKIP_SETUP = '1';
   }
+  if (imageWorkspaceMode) {
+    env.NIANCODE_IMAGE_WORKSPACE_MODE = imageWorkspaceMode;
+  }
   if (process.platform === 'linux') {
     env.ELECTRON_DISABLE_SANDBOX = '1';
   }
@@ -112,13 +117,19 @@ function buildElectronEnvironment(
 
 async function launchMakeloreElectron(
   resources: ElectronTestResources,
-  skipSetup: boolean,
+  options: LaunchElectronOptions,
 ): Promise<ElectronApplication> {
   const hostApiPort = await allocatePort();
+  const skipSetup = options.skipSetup ?? resources.defaultSkipSetup;
   const app = await electron.launch({
     executablePath: electronBinaryPath as unknown as string,
     args: [electronEntry],
-    env: buildElectronEnvironment(resources, skipSetup, hostApiPort),
+    env: buildElectronEnvironment(
+      resources,
+      skipSetup,
+      hostApiPort,
+      options.imageWorkspaceMode,
+    ),
     timeout: 90_000,
   });
 
@@ -248,8 +259,7 @@ export const test = base.extend<ElectronFixtures>({
 
   launchElectronApp: async ({ electronTestResources }, provideLauncher) => {
     await provideLauncher(async (options = {}) => {
-      const skipSetup = options.skipSetup ?? electronTestResources.defaultSkipSetup;
-      return await launchMakeloreElectron(electronTestResources, skipSetup);
+      return await launchMakeloreElectron(electronTestResources, options);
     });
   },
 
diff --git a/tests/e2e/image-workspace-conversations.spec.ts b/tests/e2e/image-workspace-conversations.spec.ts
new file mode 100644
index 0000000..36810aa
--- /dev/null
+++ b/tests/e2e/image-workspace-conversations.spec.ts
@@ -0,0 +1,52 @@
+import { closeElectronApp, expect, getStableWindow, test } from './fixtures/electron';
+
+test.describe('AI Design conversations', () => {
+  test('keeps generation tasks visible while conversations stay independent', async ({ launchElectronApp }) => {
+    const app = await launchElectronApp({
+      imageWorkspaceMode: 'local',
+      skipSetup: true,
+    });
+
+    try {
+      const page = await getStableWindow(app);
+      await page.getByTestId('sidebar-module-switcher-trigger').click();
+      await page.getByTestId('sidebar-module-painting').click();
+
+      await page.getByTestId('sidebar-create-image-project').click();
+      await page.getByLabel('项目名称').fill('多会话验收项目');
+      await page.getByRole('button', { name: '创建项目' }).click();
+
+      const conversationSelect = page.getByTestId('image-canvas-conversation-select');
+      await expect(conversationSelect).toBeVisible();
+      await expect(conversationSelect.locator('option')).toHaveCount(1);
+      const firstConversationId = await conversationSelect.inputValue();
+
+      const firstPrompt = '为项目设计一张蓝色星空海报';
+      await page.getByLabel('设计需求').fill(firstPrompt);
+      await page.getByRole('button', { name: '发送给设计 Agent' }).click();
+      await expect(page.getByTestId('image-workspace-conversation')).toContainText(firstPrompt);
+      await page.getByRole('button', { name: '确认并开始生成' }).click();
+
+      const task = page.locator('[data-testid^="design-task-"]').first();
+      await expect(task).toContainText(firstPrompt);
+
+      await page.getByRole('button', { name: '新建设计会话' }).first().click();
+      await expect(conversationSelect.locator('option')).toHaveCount(2);
+      await expect(conversationSelect).not.toHaveValue(firstConversationId);
+      await expect(page.getByTestId('image-workspace-conversation')).not.toContainText(firstPrompt);
+      await expect(task).toContainText(firstPrompt);
+
+      const secondPrompt = '这一条会话只讨论红色角色立绘';
+      await page.getByLabel('设计需求').fill(secondPrompt);
+      await page.getByRole('button', { name: '发送给设计 Agent' }).click();
+      await expect(page.getByTestId('image-workspace-conversation')).toContainText(secondPrompt);
+
+      await conversationSelect.selectOption(firstConversationId);
+      await expect(page.getByTestId('image-workspace-conversation')).toContainText(firstPrompt);
+      await expect(page.getByTestId('image-workspace-conversation')).not.toContainText(secondPrompt);
+      await expect(task).toContainText(firstPrompt);
+    } finally {
+      await closeElectronApp(app);
+    }
+  });
+});
diff --git a/tests/unit/image-canvas-page.test.tsx b/tests/unit/image-canvas-page.test.tsx
index 2b75a91..407ee84 100644
--- a/tests/unit/image-canvas-page.test.tsx
+++ b/tests/unit/image-canvas-page.test.tsx
@@ -7,6 +7,7 @@ import { useAuthStore } from '@/stores/auth';
 import { useImageWorkspaceStore } from '@/stores/image-workspace';
 import type {
   DesignAssistantDeltaEvent,
+  DesignConversation,
   DesignGenerationTask,
   DesignGenerationTaskUpdatedEvent,
   DesignWorkspace,
@@ -15,6 +16,8 @@ import type {
 
 const fetchImageWorkspaceMock = vi.hoisted(() => vi.fn());
 const fetchImageWorkspaceProjectMock = vi.hoisted(() => vi.fn());
+const fetchImageWorkspaceConversationMock = vi.hoisted(() => vi.fn());
+const createImageWorkspaceConversationMock = vi.hoisted(() => vi.fn());
 const fetchImageWorkspaceTasksMock = vi.hoisted(() => vi.fn());
 const sendImageWorkspaceMessageMock = vi.hoisted(() => vi.fn());
 const confirmImageWorkspaceGenerationMock = vi.hoisted(() => vi.fn());
@@ -57,6 +60,12 @@ vi.mock('@/lib/image-workspace', async (importOriginal) => {
     ...actual,
     fetchImageWorkspace: (...args: unknown[]) => fetchImageWorkspaceMock(...args),
     fetchImageWorkspaceProject: (...args: unknown[]) => fetchImageWorkspaceProjectMock(...args),
+    fetchImageWorkspaceConversation: (...args: unknown[]) => (
+      fetchImageWorkspaceConversationMock(...args)
+    ),
+    createImageWorkspaceConversation: (...args: unknown[]) => (
+      createImageWorkspaceConversationMock(...args)
+    ),
     fetchImageWorkspaceTasks: (...args: unknown[]) => fetchImageWorkspaceTasksMock(...args),
     sendImageWorkspaceMessage: (...args: unknown[]) => sendImageWorkspaceMessageMock(...args),
     confirmImageWorkspaceGeneration: (...args: unknown[]) => (
@@ -87,8 +96,19 @@ const bootstrapFixture: DesignWorkspaceBootstrap = {
   workspaces: [{
     workspaceId: 'workspace-cloud',
     title: '云端角色设定',
-    turnRevision: 1,
     viewRevision: 1,
+    conversationCount: 1,
+    phase: 'awaiting_confirmation',
+    updatedAt: '2026-07-31T10:00:00Z',
+  }],
+};
+
+function conversationFixture(): DesignConversation {
+  return {
+    conversationId: 'conversation-cloud',
+    workspaceId: 'workspace-cloud',
+    title: '主会话',
+    turnRevision: 1,
     phase: 'awaiting_confirmation',
     brief: {
       version: 1,
@@ -98,13 +118,8 @@ const bootstrapFixture: DesignWorkspaceBootstrap = {
       ready: true,
       missingDecision: null,
     },
+    createdAt: '2026-07-31T10:00:00Z',
     updatedAt: '2026-07-31T10:00:00Z',
-  }],
-};
-
-function workspaceFixture(): DesignWorkspace {
-  return {
-    ...bootstrapFixture.workspaces[0],
     messages: [
       {
         id: 'message-user',
@@ -138,9 +153,18 @@ function workspaceFixture(): DesignWorkspace {
   };
 }
 
+function workspaceFixture(): DesignWorkspace {
+  const { messages: _messages, ...summary } = conversationFixture();
+  return {
+    ...bootstrapFixture.workspaces[0],
+    conversations: [summary],
+  };
+}
+
 const taskFixture: DesignGenerationTask = {
   taskId: 'task-one',
   workspaceId: 'workspace-cloud',
+  conversationId: 'conversation-cloud',
   medium: 'image',
   status: 'succeeded',
   briefVersion: 1,
@@ -171,10 +195,12 @@ describe('ImageCanvas Workspace-first design experience', () => {
     useImageWorkspaceStore.getState().reset();
     fetchImageWorkspaceMock.mockResolvedValue(bootstrapFixture);
     fetchImageWorkspaceProjectMock.mockResolvedValue(workspaceFixture());
+    fetchImageWorkspaceConversationMock.mockResolvedValue(conversationFixture());
+    createImageWorkspaceConversationMock.mockResolvedValue(conversationFixture());
     fetchImageWorkspaceTasksMock.mockResolvedValue([taskFixture]);
-    sendImageWorkspaceMessageMock.mockResolvedValue(workspaceFixture());
+    sendImageWorkspaceMessageMock.mockResolvedValue(conversationFixture());
     confirmImageWorkspaceGenerationMock.mockResolvedValue({
-      ...workspaceFixture(),
+      ...conversationFixture(),
       turnRevision: 2,
       phase: 'shaping',
     });
@@ -212,7 +238,8 @@ describe('ImageCanvas Workspace-first design experience', () => {
       loading: false,
       error: null,
       accessToken: 'expired-access-token',
-      refreshToken: 'invalid-refresh-token',
+      canRefresh: true,
+      legacyRefreshToken: 'invalid-refresh-token',
       tokenType: 'Bearer',
       expiresAt: Date.now() - 1,
       user: {
@@ -234,14 +261,16 @@ describe('ImageCanvas Workspace-first design experience', () => {
     await screen.findByTestId('image-workspace-unavailable');
     expect(useAuthStore.getState()).toMatchObject({
       accessToken: null,
-      refreshToken: null,
+      canRefresh: false,
+      legacyRefreshToken: null,
       user: null,
     });
     expect(useImageWorkspaceStore.getState().status).toBe('auth-required');
 
     useAuthStore.setState({
       accessToken: 'fresh-access-token',
-      refreshToken: 'fresh-refresh-token',
+      canRefresh: true,
+      legacyRefreshToken: 'fresh-refresh-token',
       tokenType: 'Bearer',
       expiresAt: Date.now() + 60_000,
       user: {
@@ -273,6 +302,77 @@ describe('ImageCanvas Workspace-first design experience', () => {
     expect(screen.queryByText(/当前 Agent/)).not.toBeInTheDocument();
   });
 
+  it('creates and switches Conversations without hiding project generation tasks', async () => {
+    const firstConversation = conversationFixture();
+    const secondConversation: DesignConversation = {
+      ...conversationFixture(),
+      conversationId: 'conversation-two',
+      title: '第二会话',
+      turnRevision: 0,
+      phase: 'shaping',
+      brief: {
+        version: 0,
+        status: 'draft',
+        medium: null,
+        summary: '',
+        ready: false,
+        missingDecision: '请描述新的设计方向',
+      },
+      messages: [{
+        id: 'message-two',
+        role: 'assistant',
+        kind: 'reply',
+        text: '这是独立的第二会话',
+        quickReplies: [],
+        generationQuote: null,
+        turnRevision: 0,
+        createdAt: '2026-07-31T10:05:00Z',
+      }],
+      createdAt: '2026-07-31T10:05:00Z',
+      updatedAt: '2026-07-31T10:05:00Z',
+    };
+    const { messages: _firstMessages, ...firstSummary } = firstConversation;
+    const { messages: _secondMessages, ...secondSummary } = secondConversation;
+    fetchImageWorkspaceProjectMock
+      .mockResolvedValueOnce(workspaceFixture())
+      .mockResolvedValue({
+        ...workspaceFixture(),
+        conversationCount: 2,
+        conversations: [secondSummary, firstSummary],
+      });
+    createImageWorkspaceConversationMock.mockResolvedValue(secondConversation);
+    fetchImageWorkspaceConversationMock.mockImplementation(
+      async (_workspaceId: string, conversationId: string) => (
+        conversationId === secondConversation.conversationId
+          ? secondConversation
+          : firstConversation
+      ),
+    );
+
+    render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
+
+    expect(await screen.findByTestId('design-task-task-one')).toHaveTextContent('已完成');
+    fireEvent.click(screen.getByRole('button', { name: '新建设计会话' }));
+
+    await waitFor(() => expect(createImageWorkspaceConversationMock)
+      .toHaveBeenCalledWith('workspace-cloud', '新会话'));
+    await waitFor(() => expect(screen.getByLabelText('切换设计会话'))
+      .toHaveValue('conversation-two'));
+    expect(screen.getByTestId('image-workspace-conversation'))
+      .toHaveTextContent('这是独立的第二会话');
+    expect(screen.getByTestId('design-task-task-one')).toHaveTextContent('已完成');
+
+    fireEvent.change(screen.getByLabelText('切换设计会话'), {
+      target: { value: 'conversation-cloud' },
+    });
+
+    await waitFor(() => expect(fetchImageWorkspaceConversationMock)
+      .toHaveBeenLastCalledWith('workspace-cloud', 'conversation-cloud'));
+    expect(screen.getByTestId('image-workspace-conversation'))
+      .toHaveTextContent('方向已经明确');
+    expect(screen.getByTestId('design-task-task-one')).toHaveTextContent('已完成');
+  });
+
   it('opens a generated image at full size and saves it through Main', async () => {
     render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
 
@@ -365,6 +465,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
 
     await waitFor(() => expect(sendImageWorkspaceMessageMock).toHaveBeenCalledWith(
       'workspace-cloud',
+      'conversation-cloud',
       1,
       '把主角换成暖色轮廓光',
       expect.stringMatching(/^turn-/),
@@ -372,8 +473,45 @@ describe('ImageCanvas Workspace-first design experience', () => {
     expect(confirmImageWorkspaceGenerationMock).not.toHaveBeenCalled();
   });
 
+  it('sends the design message with Enter', async () => {
+    render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
+    await screen.findByText('云端角色设定');
+    const composer = screen.getByLabelText('设计需求');
+
+    fireEvent.change(composer, {
+      target: { value: '让画面增加一层晨雾' },
+    });
+    fireEvent.keyDown(composer, { key: 'Enter' });
+
+    await waitFor(() => expect(sendImageWorkspaceMessageMock).toHaveBeenCalledWith(
+      'workspace-cloud',
+      'conversation-cloud',
+      1,
+      '让画面增加一层晨雾',
+      expect.stringMatching(/^turn-/),
+    ));
+    expect(composer).toHaveValue('');
+    expect(screen.getByTestId('image-workspace-composer'))
+      .toHaveTextContent('Enter 发送 · Shift+Enter 换行');
+  });
+
+  it('keeps Shift+Enter for newlines and ignores Enter during IME composition', async () => {
+    render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
+    await screen.findByText('云端角色设定');
+    const composer = screen.getByLabelText('设计需求');
+
+    fireEvent.change(composer, {
+      target: { value: '正在输入中文设计描述' },
+    });
+    fireEvent.keyDown(composer, { key: 'Enter', shiftKey: true });
+    fireEvent.keyDown(composer, { key: 'Enter', isComposing: true });
+
+    expect(sendImageWorkspaceMessageMock).not.toHaveBeenCalled();
+    expect(composer).toHaveValue('正在输入中文设计描述');
+  });
+
   it('renders the pending user turn and assistant deltas while the command is running', async () => {
-    const response = deferred<DesignWorkspace>();
+    const response = deferred<DesignConversation>();
     sendImageWorkspaceMessageMock.mockReturnValueOnce(response.promise);
     render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
     await screen.findByText('云端角色设定');
@@ -392,6 +530,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
         id: 'session-one:2',
         type: 'design.assistant.delta',
         workspaceId: 'workspace-cloud',
+        conversationId: 'conversation-cloud',
         clientTurnId: pending.clientTurnId,
         turnRevision: pending.turnRevision,
         chunkIndex: 0,
@@ -409,6 +548,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
         id: 'session-one:3',
         type: 'design.assistant.delta',
         workspaceId: 'workspace-cloud',
+        conversationId: 'conversation-cloud',
         clientTurnId: pending.clientTurnId,
         turnRevision: pending.turnRevision,
         chunkIndex: 1,
@@ -419,15 +559,14 @@ describe('ImageCanvas Workspace-first design experience', () => {
     expect(screen.getByTestId('image-workspace-conversation'))
       .toHaveTextContent('可以先增加留白和水流节奏。');
     act(() => response.resolve({
-      ...workspaceFixture(),
+      ...conversationFixture(),
       turnRevision: 2,
-      viewRevision: 2,
     }));
     await waitFor(() => expect(useImageWorkspaceStore.getState().pendingTurn).toBeNull());
   });
 
   it('never downgrades confirmation to normal chat when no active Quote exists', async () => {
-    const workspaceWithoutQuote = workspaceFixture();
+    const workspaceWithoutQuote = conversationFixture();
     workspaceWithoutQuote.messages[1] = {
       ...workspaceWithoutQuote.messages[1],
       generationQuote: null,
@@ -441,7 +580,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
         video: false,
       },
     });
-    fetchImageWorkspaceProjectMock.mockResolvedValueOnce(workspaceWithoutQuote);
+    fetchImageWorkspaceConversationMock.mockResolvedValueOnce(workspaceWithoutQuote);
 
     render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
     const confirmReply = await screen.findByRole('button', { name: '确认生成' });
@@ -474,6 +613,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
     await waitFor(() => expect(confirmImageWorkspaceGenerationMock)
       .toHaveBeenCalledWith(
         'workspace-cloud',
+        'conversation-cloud',
         1,
         'quote-one',
         expect.stringMatching(/^turn-/),
@@ -503,6 +643,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
     await waitFor(() => expect(confirmImageWorkspaceGenerationMock)
       .toHaveBeenCalledWith(
         'workspace-cloud',
+        'conversation-cloud',
         1,
         'quote-one',
         expect.stringMatching(/^turn-/),
@@ -524,6 +665,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
 
     await waitFor(() => expect(sendImageWorkspaceMessageMock).toHaveBeenCalledWith(
       'workspace-cloud',
+      'conversation-cloud',
       1,
       question,
       expect.stringMatching(/^turn-/),
@@ -532,8 +674,8 @@ describe('ImageCanvas Workspace-first design experience', () => {
   });
 
   it('opens the successful work picker when the Agent asks for a video first frame', async () => {
-    fetchImageWorkspaceProjectMock.mockResolvedValueOnce({
-      ...workspaceFixture(),
+    fetchImageWorkspaceConversationMock.mockResolvedValueOnce({
+      ...conversationFixture(),
       phase: 'shaping',
       brief: {
         version: 2,
@@ -544,7 +686,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
         missingDecision: '请选择首帧来源',
       },
       messages: [
-        ...workspaceFixture().messages,
+        ...conversationFixture().messages,
         {
           id: 'message-video-source',
           role: 'assistant',
@@ -556,7 +698,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
           createdAt: '2026-08-06T09:00:00Z',
         },
       ],
-    } satisfies DesignWorkspace);
+    } satisfies DesignConversation);
     render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
 
     fireEvent.click(await screen.findByRole('button', { name: '从作品列表选择图片' }));
@@ -570,13 +712,13 @@ describe('ImageCanvas Workspace-first design experience', () => {
   });
 
   it('submits a successful work Asset id when it is selected as the video first frame', async () => {
-    const pendingSelection = deferred<DesignWorkspace>();
+    const pendingSelection = deferred<DesignConversation>();
     sendImageWorkspaceMessageMock.mockReturnValueOnce(pendingSelection.promise);
-    fetchImageWorkspaceProjectMock.mockResolvedValueOnce({
-      ...workspaceFixture(),
+    fetchImageWorkspaceConversationMock.mockResolvedValueOnce({
+      ...conversationFixture(),
       turnRevision: 2,
       messages: [
-        ...workspaceFixture().messages,
+        ...conversationFixture().messages,
         {
           id: 'message-video-source',
           role: 'assistant',
@@ -588,7 +730,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
           createdAt: '2026-08-06T09:00:00Z',
         },
       ],
-    } satisfies DesignWorkspace);
+    } satisfies DesignConversation);
     render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
     fireEvent.click(await screen.findByRole('button', { name: '从作品列表选择图片' }));
 
@@ -600,6 +742,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
 
     await waitFor(() => expect(sendImageWorkspaceMessageMock).toHaveBeenCalledWith(
       'workspace-cloud',
+      'conversation-cloud',
       2,
       '使用作品图片作为视频首帧',
       expect.stringMatching(/^turn-/),
@@ -608,16 +751,16 @@ describe('ImageCanvas Workspace-first design experience', () => {
     expect(screen.queryByRole('dialog', { name: '选择视频首帧' })).not.toBeInTheDocument();
 
     await act(async () => {
-      pendingSelection.resolve(workspaceFixture());
+      pendingSelection.resolve(conversationFixture());
       await pendingSelection.promise;
     });
   });
 
   it('uploads a local first-frame image and submits its Asset id to the Agent', async () => {
-    fetchImageWorkspaceProjectMock.mockResolvedValueOnce({
-      ...workspaceFixture(),
+    fetchImageWorkspaceConversationMock.mockResolvedValueOnce({
+      ...conversationFixture(),
       messages: [
-        ...workspaceFixture().messages,
+        ...conversationFixture().messages,
         {
           id: 'message-video-source',
           role: 'assistant',
@@ -630,7 +773,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
         },
       ],
       turnRevision: 2,
-    } satisfies DesignWorkspace);
+    } satisfies DesignConversation);
     render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
     fireEvent.click(await screen.findByRole('button', { name: '从作品列表选择图片' }));
     const picker = screen.getByRole('dialog', { name: '选择视频首帧' });
@@ -644,6 +787,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
       .toHaveBeenCalledWith('workspace-cloud', file));
     await waitFor(() => expect(sendImageWorkspaceMessageMock).toHaveBeenCalledWith(
       'workspace-cloud',
+      'conversation-cloud',
       2,
       '使用上传的图片作为视频首帧',
       expect.stringMatching(/^turn-/),
@@ -678,7 +822,7 @@ describe('ImageCanvas Workspace-first design experience', () => {
     render(<MemoryRouter><ImageCanvas /></MemoryRouter>);
     await screen.findByTestId('design-quote-quote-one');
     await waitFor(() => expect(openImageWorkspaceTaskEventsMock)
-      .toHaveBeenCalledWith('workspace-cloud'));
+      .toHaveBeenCalledWith('workspace-cloud', 'conversation-cloud'));
     await waitFor(() => expect(taskEventSource.onopen).not.toBeNull());
     act(() => {
       taskEventSource.onopen?.(new Event('open'));
diff --git a/tests/unit/image-workspace-api.test.ts b/tests/unit/image-workspace-api.test.ts
index 709d7a6..c082f08 100644
--- a/tests/unit/image-workspace-api.test.ts
+++ b/tests/unit/image-workspace-api.test.ts
@@ -8,8 +8,10 @@ import {
 } from '@/lib/host-api';
 import {
   confirmImageWorkspaceGeneration,
+  createImageWorkspaceConversation,
   createImageWorkspaceProject,
   fetchImageWorkspace,
+  fetchImageWorkspaceConversation,
   ImageWorkspaceApiError,
   openImageWorkspaceTaskEvents,
   resolveImageWorkspaceAssetUrl,
@@ -59,11 +61,11 @@ describe('AI design renderer API boundary', () => {
   });
 
   it('opens task events only after the local Host API token is ready', async () => {
-    const source = await openImageWorkspaceTaskEvents('workspace/one');
+    const source = await openImageWorkspaceTaskEvents('workspace/one', 'conversation/one');
 
     expect(source).toBe(createHostEventSourceMock.mock.results[0].value);
     expect(createHostEventSourceMock).toHaveBeenCalledWith(
-      '/api/works/image-workspace/workspaces/workspace%2Fone/events',
+      '/api/works/image-workspace/workspaces/workspace%2Fone/conversations/conversation%2Fone/events',
     );
     expect(ensureHostApiTokenMock.mock.invocationCallOrder[0])
       .toBeLessThan(createHostEventSourceMock.mock.invocationCallOrder[0]);
@@ -81,16 +83,43 @@ describe('AI design renderer API boundary', () => {
     });
   });
 
+  it('creates and reads Conversations through encoded Main-owned routes', async () => {
+    await createImageWorkspaceConversation(
+      'workspace/one',
+      '  第二会话  ',
+      'client-conversation-one',
+    );
+    await fetchImageWorkspaceConversation('workspace/one', 'conversation/one');
+
+    expect(hostApiFetchMock).toHaveBeenNthCalledWith(
+      1,
+      '/api/works/image-workspace/workspaces/workspace%2Fone/conversations',
+      {
+        method: 'POST',
+        body: JSON.stringify({
+          clientConversationId: 'client-conversation-one',
+          title: '第二会话',
+        }),
+      },
+    );
+    expect(hostApiFetchMock).toHaveBeenNthCalledWith(
+      2,
+      '/api/works/image-workspace/workspaces/workspace%2Fone/conversations/conversation%2Fone',
+      {},
+    );
+  });
+
   it('sends conversation turns with the current turn revision and no provider settings', async () => {
     await sendImageWorkspaceMessage(
       'workspace/one',
+      'conversation/one',
       4,
       '  继续调整构图  ',
       'turn-client-1',
     );
 
     const [path, init] = hostApiFetchMock.mock.calls[0];
-    expect(path).toBe('/api/works/image-workspace/workspaces/workspace%2Fone/messages');
+    expect(path).toBe('/api/works/image-workspace/workspaces/workspace%2Fone/conversations/conversation%2Fone/messages');
     expect(init).toMatchObject({ method: 'POST' });
     expect(JSON.parse(String(init?.body))).toMatchObject({
       expectedTurnRevision: 4,
@@ -104,6 +133,7 @@ describe('AI design renderer API boundary', () => {
   it('sends the selected first-frame Asset id with the conversation turn', async () => {
     await sendImageWorkspaceMessage(
       'workspace-one',
+      'conversation-one',
       5,
       '使用作品图片作为视频首帧',
       'turn-first-frame',
@@ -148,11 +178,11 @@ describe('AI design renderer API boundary', () => {
   });
 
   it('confirms a Quote through a separate structured action route', async () => {
-    await confirmImageWorkspaceGeneration('workspace-one', 5, 'quote/one');
+    await confirmImageWorkspaceGeneration('workspace-one', 'conversation-one', 5, 'quote/one');
 
     const [path, init] = hostApiFetchMock.mock.calls[0];
     expect(path).toBe(
-      '/api/works/image-workspace/workspaces/workspace-one/quotes/quote%2Fone/confirm',
+      '/api/works/image-workspace/workspaces/workspace-one/conversations/conversation-one/quotes/quote%2Fone/confirm',
     );
     expect(JSON.parse(String(init?.body))).toMatchObject({
       expectedTurnRevision: 5,
diff --git a/tests/unit/image-workspace-route.test.ts b/tests/unit/image-workspace-route.test.ts
index cbe4f72..45e0610 100644
--- a/tests/unit/image-workspace-route.test.ts
+++ b/tests/unit/image-workspace-route.test.ts
@@ -130,6 +130,8 @@ describe('AI design Main route boundary', () => {
     const workspace = {
       bootstrap: vi.fn().mockResolvedValue(bootstrap),
       createWorkspace: vi.fn().mockResolvedValue({ workspaceId: 'workspace-one' }),
+      createConversation: vi.fn().mockResolvedValue({ conversationId: 'conversation-one' }),
+      getConversation: vi.fn().mockResolvedValue({ conversationId: 'conversation/one' }),
       renameWorkspace: vi.fn(),
       getWorkspace: vi.fn(),
       submitMessage: vi.fn().mockResolvedValue({ workspaceId: 'workspace/one' }),
@@ -166,6 +168,43 @@ describe('AI design Main route boundary', () => {
       title: '角色设计',
     });
 
+    const createConversationResponse = createResponse();
+    await handleImageWorkspaceRoutes(
+      createRequest('POST', {
+        clientConversationId: 'client-conversation-one',
+        title: '第二会话',
+      }),
+      createConversationResponse.res,
+      new URL(
+        'http://127.0.0.1/api/works/image-workspace/workspaces/workspace%2Fone/conversations',
+      ),
+      ctx,
+    );
+    expect(workspace.createConversation).toHaveBeenCalledWith({
+      workspaceId: 'workspace/one',
+      clientConversationId: 'client-conversation-one',
+      title: '第二会话',
+    });
+    expect(createConversationResponse.json()).toMatchObject({
+      success: true,
+      data: { conversationId: 'conversation-one' },
+    });
+
+    const getConversationResponse = createResponse();
+    await handleImageWorkspaceRoutes(
+      createRequest('GET'),
+      getConversationResponse.res,
+      new URL(
+        'http://127.0.0.1/api/works/image-workspace/workspaces/workspace%2Fone/conversations/conversation%2Fone',
+      ),
+      ctx,
+    );
+    expect(workspace.getConversation).toHaveBeenCalledWith('workspace/one', 'conversation/one');
+    expect(getConversationResponse.json()).toMatchObject({
+      success: true,
+      data: { conversationId: 'conversation/one' },
+    });
+
     const messageResponse = createResponse();
     await handleImageWorkspaceRoutes(
       createRequest('POST', {
@@ -177,12 +216,13 @@ describe('AI design Main route boundary', () => {
       }),
       messageResponse.res,
       new URL(
-        'http://127.0.0.1/api/works/image-workspace/workspaces/workspace%2Fone/messages',
+        'http://127.0.0.1/api/works/image-workspace/workspaces/workspace%2Fone/conversations/conversation%2Fone/messages',
       ),
       ctx,
     );
     expect(workspace.submitMessage).toHaveBeenCalledWith({
       workspaceId: 'workspace/one',
+      conversationId: 'conversation/one',
       clientTurnId: 'turn-one',
       expectedTurnRevision: 3,
       message: '继续编辑',
@@ -221,12 +261,13 @@ describe('AI design Main route boundary', () => {
       }),
       confirmResponse.res,
       new URL(
-        'http://127.0.0.1/api/works/image-workspace/workspaces/workspace%2Fone/quotes/quote%2Fone/confirm',
+        'http://127.0.0.1/api/works/image-workspace/workspaces/workspace%2Fone/conversations/conversation%2Fone/quotes/quote%2Fone/confirm',
       ),
       ctx,
     );
     expect(workspace.confirmGeneration).toHaveBeenCalledWith({
       workspaceId: 'workspace/one',
+      conversationId: 'conversation/one',
       quoteId: 'quote/one',
       clientTurnId: 'turn-two',
       expectedTurnRevision: 4,
@@ -391,6 +432,7 @@ describe('AI design Main route boundary', () => {
           generationTask: {
             taskId: 'task-live',
             workspaceId: 'workspace/one',
+            conversationId: 'conversation/one',
             medium: 'image' as const,
             status: 'succeeded' as const,
             briefVersion: 1,
@@ -414,7 +456,7 @@ describe('AI design Main route boundary', () => {
       request,
       response as unknown as ServerResponse,
       new URL(
-        'http://127.0.0.1/api/works/image-workspace/workspaces/workspace%2Fone/events',
+        'http://127.0.0.1/api/works/image-workspace/workspaces/workspace%2Fone/conversations/conversation%2Fone/events',
       ),
       { imageWorkspace: { openWorkspaceEvents } } as unknown as HostApiContext,
     );
@@ -422,6 +464,7 @@ describe('AI design Main route boundary', () => {
     expect(handled).toBe(true);
     expect(openWorkspaceEvents).toHaveBeenCalledWith({
       workspaceId: 'workspace/one',
+      conversationId: 'conversation/one',
       afterEventId: 'session-one:6',
     });
     expect(response.statusCode).toBe(200);
diff --git a/tests/unit/image-workspace-store.test.ts b/tests/unit/image-workspace-store.test.ts
index 6671223..1a1ddfb 100644
--- a/tests/unit/image-workspace-store.test.ts
+++ b/tests/unit/image-workspace-store.test.ts
@@ -2,8 +2,9 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import { useImageWorkspaceStore } from '@/stores/image-workspace';
 import type {
   DesignAssistantDeltaEvent,
+  DesignConversation,
+  DesignConversationSnapshotEvent,
   DesignGenerationTask,
-  DesignGenerationTasksSnapshotEvent,
   DesignGenerationTaskUpdatedEvent,
   DesignWorkspace,
   DesignWorkspaceBootstrap,
@@ -11,6 +12,8 @@ import type {
 
 const fetchImageWorkspaceMock = vi.hoisted(() => vi.fn());
 const fetchImageWorkspaceProjectMock = vi.hoisted(() => vi.fn());
+const fetchImageWorkspaceConversationMock = vi.hoisted(() => vi.fn());
+const createImageWorkspaceConversationMock = vi.hoisted(() => vi.fn());
 const fetchImageWorkspaceTasksMock = vi.hoisted(() => vi.fn());
 const openImageWorkspaceTaskEventsMock = vi.hoisted(() => vi.fn());
 const sendImageWorkspaceMessageMock = vi.hoisted(() => vi.fn());
@@ -22,6 +25,12 @@ vi.mock('@/lib/image-workspace', async (importOriginal) => {
     ...actual,
     fetchImageWorkspace: (...args: unknown[]) => fetchImageWorkspaceMock(...args),
     fetchImageWorkspaceProject: (...args: unknown[]) => fetchImageWorkspaceProjectMock(...args),
+    fetchImageWorkspaceConversation: (...args: unknown[]) => (
+      fetchImageWorkspaceConversationMock(...args)
+    ),
+    createImageWorkspaceConversation: (...args: unknown[]) => (
+      createImageWorkspaceConversationMock(...args)
+    ),
     fetchImageWorkspaceTasks: (...args: unknown[]) => fetchImageWorkspaceTasksMock(...args),
     openImageWorkspaceTaskEvents: (...args: unknown[]) => openImageWorkspaceTaskEventsMock(...args),
     sendImageWorkspaceMessage: (...args: unknown[]) => sendImageWorkspaceMessageMock(...args),
@@ -62,6 +71,7 @@ function deferred<T>(): { promise: Promise<T>; resolve(value: T): void } {
 const task: DesignGenerationTask = {
   taskId: 'task-one',
   workspaceId: 'workspace-one',
+  conversationId: 'conversation-one',
   medium: 'image',
   status: 'queued',
   briefVersion: 1,
@@ -74,12 +84,16 @@ const task: DesignGenerationTask = {
   updatedAt: '2026-08-02T10:00:00Z',
 };
 
-function workspace(workspaceId = 'workspace-one', viewRevision = 1): DesignWorkspace {
+function conversation(
+  workspaceId = 'workspace-one',
+  turnRevision = 1,
+  conversationId = workspaceId.replace('workspace', 'conversation'),
+): DesignConversation {
   return {
+    conversationId,
     workspaceId,
-    title: workspaceId,
-    turnRevision: 1,
-    viewRevision,
+    title: '主会话',
+    turnRevision,
     phase: 'shaping',
     brief: {
       version: 1,
@@ -91,6 +105,20 @@ function workspace(workspaceId = 'workspace-one', viewRevision = 1): DesignWorks
     },
     updatedAt: '2026-08-02T10:00:00Z',
     messages: [],
+    createdAt: '2026-08-02T10:00:00Z',
+  };
+}
+
+function workspace(workspaceId = 'workspace-one', viewRevision = 1): DesignWorkspace {
+  const { messages: _messages, ...conversationSummary } = conversation(workspaceId);
+  return {
+    workspaceId,
+    title: workspaceId,
+    viewRevision,
+    conversationCount: 1,
+    phase: conversationSummary.phase,
+    updatedAt: '2026-08-02T10:00:00Z',
+    conversations: [conversationSummary],
   };
 }
 
@@ -98,7 +126,7 @@ function bootstrap(workspaceIds = ['workspace-one']): DesignWorkspaceBootstrap {
   return {
     capabilities: { conversation: true, generation: true, image: true, video: true },
     workspaces: workspaceIds.map((workspaceId) => {
-      const { messages: _messages, ...summary } = workspace(workspaceId);
+      const { conversations: _conversations, ...summary } = workspace(workspaceId);
       return summary;
     }),
   };
@@ -124,13 +152,14 @@ function taskEvent(
 function taskSnapshotEvent(
   workspaceViewRevision: number,
   status: DesignGenerationTask['status'],
-): DesignGenerationTasksSnapshotEvent {
+): DesignConversationSnapshotEvent {
   return {
     id: `session-one:${workspaceViewRevision}`,
-    type: 'design.generation_tasks.snapshot',
+    type: 'design.conversation.snapshot',
     workspaceId: 'workspace-one',
+    conversationId: 'conversation-one',
     workspaceViewRevision,
-    workspace: workspace('workspace-one', workspaceViewRevision),
+    conversation: conversation('workspace-one', workspaceViewRevision),
     generationTasks: [{
       ...task,
       status,
@@ -146,10 +175,16 @@ describe('AI design task event store', () => {
     useImageWorkspaceStore.getState().reset();
     fetchImageWorkspaceMock.mockResolvedValue(bootstrap());
     fetchImageWorkspaceProjectMock.mockResolvedValue(workspace());
+    fetchImageWorkspaceConversationMock.mockImplementation((workspaceId: string, conversationId: string) => (
+      Promise.resolve(conversation(workspaceId, 1, conversationId))
+    ));
+    createImageWorkspaceConversationMock.mockResolvedValue(
+      conversation('workspace-one', 0, 'conversation-new'),
+    );
     fetchImageWorkspaceTasksMock.mockResolvedValue([task]);
-    sendImageWorkspaceMessageMock.mockResolvedValue(workspace());
+    sendImageWorkspaceMessageMock.mockResolvedValue(conversation());
     confirmImageWorkspaceGenerationMock.mockResolvedValue({
-      ...workspace('workspace-one', 2),
+      ...conversation('workspace-one', 2),
       turnRevision: 2,
     });
   });
@@ -159,30 +194,30 @@ describe('AI design task event store', () => {
     vi.useRealTimers();
   });
 
-  it('keeps a revision-5 snapshot over revision 3, then upserts a newer task by task id', async () => {
+  it('uses task event revisions instead of the project view revision as the task watermark', async () => {
     const source = new MockEventSource();
     openImageWorkspaceTaskEventsMock.mockResolvedValue(source as unknown as EventSource);
-    fetchImageWorkspaceProjectMock.mockResolvedValue(workspace('workspace-one', 5));
+    fetchImageWorkspaceProjectMock.mockResolvedValue(workspace('workspace-one', 50));
 
     await useImageWorkspaceStore.getState().load();
     await vi.waitFor(() => expect(openImageWorkspaceTaskEventsMock)
-      .toHaveBeenCalledWith('workspace-one'));
+      .toHaveBeenCalledWith('workspace-one', 'conversation-one'));
     source.onopen?.(new Event('open'));
     source.emit('design.generation_task.updated', taskEvent(3, 'failed'));
-    expect(useImageWorkspaceStore.getState().tasks[0].status).toBe('queued');
-    source.emit('design.generation_tasks.snapshot', taskSnapshotEvent(6, 'running'));
+    expect(useImageWorkspaceStore.getState().tasks[0].status).toBe('failed');
+    source.emit('design.conversation.snapshot', taskSnapshotEvent(6, 'running'));
     source.emit('design.generation_task.updated', taskEvent(5, 'failed'));
 
     expect(useImageWorkspaceStore.getState()).toMatchObject({
       taskStreamState: 'connected',
-      workspace: { viewRevision: 6 },
+      workspace: { viewRevision: 50 },
       tasks: [{ taskId: 'task-one', status: 'running' }],
     });
   });
 
   it('assembles assistant deltas once and replaces them with the canonical snapshot', async () => {
     const source = new MockEventSource();
-    const response = deferred<DesignWorkspace>();
+    const response = deferred<DesignConversation>();
     openImageWorkspaceTaskEventsMock.mockResolvedValue(source as unknown as EventSource);
     sendImageWorkspaceMessageMock.mockReturnValueOnce(response.promise);
 
@@ -200,6 +235,7 @@ describe('AI design task event store', () => {
       id: 'session-one:2',
       type: 'design.assistant.delta',
       workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
       clientTurnId: pending!.clientTurnId,
       turnRevision: 2,
       chunkIndex: 0,
@@ -218,7 +254,7 @@ describe('AI design task event store', () => {
       .toBe('可以，先强化鲸鱼的轮廓。');
 
     const canonical = {
-      ...workspace('workspace-one', 2),
+      ...conversation('workspace-one', 2),
       turnRevision: 2,
       messages: [{
         id: 'workspace-one:2:assistant:0',
@@ -231,14 +267,14 @@ describe('AI design task event store', () => {
         createdAt: '2026-08-02T10:01:00Z',
       }],
     };
-    source.emit('design.generation_tasks.snapshot', {
+    source.emit('design.conversation.snapshot', {
       ...taskSnapshotEvent(2, 'queued'),
       id: 'session-one:4',
-      workspace: canonical,
-    } satisfies DesignGenerationTasksSnapshotEvent);
+      conversation: canonical,
+    } satisfies DesignConversationSnapshotEvent);
 
     expect(useImageWorkspaceStore.getState().pendingTurn).toBeNull();
-    expect(useImageWorkspaceStore.getState().workspace?.messages[0].text)
+    expect(useImageWorkspaceStore.getState().conversation?.messages[0].text)
       .toBe('可以，先强化鲸鱼的轮廓。');
     response.resolve(canonical);
     await sending;
@@ -257,6 +293,7 @@ describe('AI design task event store', () => {
 
     expect(confirmImageWorkspaceGenerationMock).toHaveBeenCalledWith(
       'workspace-one',
+      'conversation-one',
       1,
       'quote-one',
       expect.stringMatching(/^turn-/),
@@ -309,7 +346,7 @@ describe('AI design task event store', () => {
   it('does not switch back when an Agent turn finishes after selecting another Workspace', async () => {
     const first = new MockEventSource();
     const second = new MockEventSource();
-    const response = deferred<DesignWorkspace>();
+    const response = deferred<DesignConversation>();
     openImageWorkspaceTaskEventsMock
       .mockResolvedValueOnce(first as unknown as EventSource)
       .mockResolvedValueOnce(second as unknown as EventSource);
@@ -323,7 +360,7 @@ describe('AI design task event store', () => {
     const sending = useImageWorkspaceStore.getState().sendMessage('继续优化海报');
     await useImageWorkspaceStore.getState().selectProject('workspace-two');
     response.resolve({
-      ...workspace('workspace-one', 2),
+      ...conversation('workspace-one', 2),
       turnRevision: 2,
     });
     await sending;
@@ -356,7 +393,7 @@ describe('AI design task event store', () => {
 
     await useImageWorkspaceStore.getState().load();
     await vi.waitFor(() => expect(openImageWorkspaceTaskEventsMock)
-      .toHaveBeenCalledWith('workspace-root'));
+      .toHaveBeenCalledWith('workspace-root', 'conversation-root'));
     const staleSelection = useImageWorkspaceStore.getState().selectProject('workspace-one');
     await vi.waitFor(() => expect(fetchImageWorkspaceProjectMock)
       .toHaveBeenCalledWith('workspace-one'));
@@ -366,10 +403,11 @@ describe('AI design task event store', () => {
 
     expect(useImageWorkspaceStore.getState().activeWorkspaceId).toBe('workspace-two');
     expect(useImageWorkspaceStore.getState().workspace?.workspaceId).toBe('workspace-two');
-    expect(openImageWorkspaceTaskEventsMock).not.toHaveBeenCalledWith('workspace-one');
+    expect(openImageWorkspaceTaskEventsMock)
+      .not.toHaveBeenCalledWith('workspace-one', 'conversation-one');
   });
 
-  it('advances each task watermark after a degraded REST snapshot', async () => {
+  it('uses updatedAt to keep a newer degraded REST task over an older replay', async () => {
     const source = new MockEventSource();
     openImageWorkspaceTaskEventsMock.mockResolvedValue(source as unknown as EventSource);
 
@@ -379,6 +417,7 @@ describe('AI design task event store', () => {
     fetchImageWorkspaceTasksMock.mockResolvedValue([{
       ...task,
       status: 'succeeded',
+      updatedAt: '2026-08-02T11:00:00Z',
     }]);
     await useImageWorkspaceStore.getState().refreshWorkspace();
     await useImageWorkspaceStore.getState().refreshTasks();
@@ -404,4 +443,203 @@ describe('AI design task event store', () => {
     await vi.advanceTimersByTimeAsync(15_000);
     expect(fetchImageWorkspaceTasksMock).toHaveBeenCalledTimes(2);
   });
+
+  it('switches the conversation stream without clearing project generation tasks', async () => {
+    const first = new MockEventSource();
+    const second = new MockEventSource();
+    openImageWorkspaceTaskEventsMock
+      .mockResolvedValueOnce(first as unknown as EventSource)
+      .mockResolvedValueOnce(second as unknown as EventSource);
+    const project = workspace();
+    const { messages: _messages, ...secondSummary } = conversation(
+      'workspace-one',
+      0,
+      'conversation-two',
+    );
+    fetchImageWorkspaceProjectMock.mockResolvedValue({
+      ...project,
+      conversationCount: 2,
+      conversations: [...project.conversations, secondSummary],
+    });
+
+    await useImageWorkspaceStore.getState().load();
+    await useImageWorkspaceStore.getState().selectConversation('conversation-two');
+
+    expect(first.close).toHaveBeenCalledOnce();
+    expect(openImageWorkspaceTaskEventsMock)
+      .toHaveBeenLastCalledWith('workspace-one', 'conversation-two');
+    expect(useImageWorkspaceStore.getState()).toMatchObject({
+      activeWorkspaceId: 'workspace-one',
+      activeConversationId: 'conversation-two',
+      conversation: { conversationId: 'conversation-two' },
+      tasks: [{ taskId: 'task-one' }],
+    });
+  });
+
+  it('accepts a lower-revision fresh task event after switching conversations', async () => {
+    const first = new MockEventSource();
+    const second = new MockEventSource();
+    openImageWorkspaceTaskEventsMock
+      .mockResolvedValueOnce(first as unknown as EventSource)
+      .mockResolvedValueOnce(second as unknown as EventSource);
+    const project = workspace('workspace-one', 50);
+    const { messages: _messages, ...secondSummary } = conversation(
+      'workspace-one',
+      0,
+      'conversation-two',
+    );
+    fetchImageWorkspaceProjectMock.mockResolvedValue({
+      ...project,
+      conversationCount: 2,
+      conversations: [...project.conversations, secondSummary],
+    });
+
+    await useImageWorkspaceStore.getState().load();
+    await useImageWorkspaceStore.getState().selectConversation('conversation-two');
+    second.emit('design.generation_task.updated', taskEvent(3, 'running'));
+
+    expect(useImageWorkspaceStore.getState()).toMatchObject({
+      activeConversationId: 'conversation-two',
+      workspace: { viewRevision: 50 },
+      tasks: [{ taskId: 'task-one', status: 'running' }],
+    });
+  });
+
+  it('does not let an older ABA conversation response replace the latest turn', async () => {
+    const source = new MockEventSource();
+    const project = workspace();
+    const { messages: _messages, ...secondSummary } = conversation(
+      'workspace-one',
+      0,
+      'conversation-two',
+    );
+    fetchImageWorkspaceProjectMock.mockResolvedValue({
+      ...project,
+      conversationCount: 2,
+      conversations: [...project.conversations, secondSummary],
+    });
+    openImageWorkspaceTaskEventsMock.mockResolvedValue(source as unknown as EventSource);
+    await useImageWorkspaceStore.getState().load();
+
+    const staleA = deferred<DesignConversation>();
+    const freshA = deferred<DesignConversation>();
+    fetchImageWorkspaceConversationMock
+      .mockReset()
+      .mockReturnValueOnce(staleA.promise)
+      .mockResolvedValueOnce(conversation('workspace-one', 2, 'conversation-two'))
+      .mockReturnValueOnce(freshA.promise);
+    const firstA = useImageWorkspaceStore.getState().selectConversation('conversation-one');
+    await useImageWorkspaceStore.getState().selectConversation('conversation-two');
+    const secondA = useImageWorkspaceStore.getState().selectConversation('conversation-one');
+    freshA.resolve({
+      ...conversation('workspace-one', 5, 'conversation-one'),
+      updatedAt: '2026-08-02T10:05:00Z',
+    });
+    await secondA;
+    staleA.resolve({
+      ...conversation('workspace-one', 4, 'conversation-one'),
+      updatedAt: '2026-08-02T10:04:00Z',
+    });
+    await firstA;
+
+    expect(useImageWorkspaceStore.getState()).toMatchObject({
+      activeConversationId: 'conversation-one',
+      conversation: { conversationId: 'conversation-one', turnRevision: 5 },
+    });
+  });
+
+  it('does not surface a late ABA conversation error on the latest selection', async () => {
+    const source = new MockEventSource();
+    const project = workspace();
+    const { messages: _messages, ...secondSummary } = conversation(
+      'workspace-one',
+      0,
+      'conversation-two',
+    );
+    fetchImageWorkspaceProjectMock.mockResolvedValue({
+      ...project,
+      conversationCount: 2,
+      conversations: [...project.conversations, secondSummary],
+    });
+    openImageWorkspaceTaskEventsMock.mockResolvedValue(source as unknown as EventSource);
+    await useImageWorkspaceStore.getState().load();
+
+    let rejectStale!: (error: unknown) => void;
+    const staleA = new Promise<DesignConversation>((_resolve, reject) => {
+      rejectStale = reject;
+    });
+    fetchImageWorkspaceConversationMock
+      .mockReset()
+      .mockReturnValueOnce(staleA)
+      .mockResolvedValueOnce(conversation('workspace-one', 2, 'conversation-two'))
+      .mockResolvedValueOnce(conversation('workspace-one', 5, 'conversation-one'));
+    const firstA = useImageWorkspaceStore.getState().selectConversation('conversation-one');
+    await useImageWorkspaceStore.getState().selectConversation('conversation-two');
+    await useImageWorkspaceStore.getState().selectConversation('conversation-one');
+    rejectStale(new Error('stale request failed'));
+    await firstA;
+
+    expect(useImageWorkspaceStore.getState()).toMatchObject({
+      activeConversationId: 'conversation-one',
+      conversation: { turnRevision: 5 },
+      error: null,
+    });
+  });
+
+  it('does not let stale ABA workspace tasks replace the latest project load', async () => {
+    const source = new MockEventSource();
+    openImageWorkspaceTaskEventsMock.mockResolvedValue(source as unknown as EventSource);
+    fetchImageWorkspaceMock.mockResolvedValue(bootstrap(['workspace-one', 'workspace-two']));
+    await useImageWorkspaceStore.getState().load();
+
+    const staleTasks = deferred<DesignGenerationTask[]>();
+    fetchImageWorkspaceProjectMock
+      .mockReset()
+      .mockResolvedValueOnce(workspace('workspace-one', 4))
+      .mockResolvedValueOnce(workspace('workspace-two', 1))
+      .mockResolvedValueOnce(workspace('workspace-one', 5));
+    fetchImageWorkspaceTasksMock
+      .mockReset()
+      .mockReturnValueOnce(staleTasks.promise)
+      .mockResolvedValueOnce([{ ...task, taskId: 'task-two', workspaceId: 'workspace-two' }])
+      .mockResolvedValueOnce([{
+        ...task,
+        status: 'succeeded',
+        updatedAt: '2026-08-02T11:00:00Z',
+      }]);
+
+    const firstA = useImageWorkspaceStore.getState().selectProject('workspace-one');
+    await vi.waitFor(() => expect(fetchImageWorkspaceTasksMock).toHaveBeenCalledOnce());
+    await useImageWorkspaceStore.getState().selectProject('workspace-two');
+    await useImageWorkspaceStore.getState().selectProject('workspace-one');
+    staleTasks.resolve([{
+      ...task,
+      status: 'failed',
+      updatedAt: '2026-08-02T10:04:00Z',
+    }]);
+    await firstA;
+
+    expect(useImageWorkspaceStore.getState()).toMatchObject({
+      activeWorkspaceId: 'workspace-one',
+      workspace: { workspaceId: 'workspace-one', viewRevision: 5 },
+      tasks: [{ taskId: 'task-one', status: 'succeeded' }],
+    });
+  });
+
+  it('prevents duplicate conversations while one create request is in flight', async () => {
+    const source = new MockEventSource();
+    const pending = deferred<DesignConversation>();
+    openImageWorkspaceTaskEventsMock.mockResolvedValue(source as unknown as EventSource);
+    createImageWorkspaceConversationMock.mockReturnValueOnce(pending.promise);
+    await useImageWorkspaceStore.getState().load();
+
+    const firstCreate = useImageWorkspaceStore.getState().createConversation();
+    await expect(useImageWorkspaceStore.getState().createConversation())
+      .rejects.toThrow('正在创建新会话');
+    expect(createImageWorkspaceConversationMock).toHaveBeenCalledOnce();
+
+    pending.resolve(conversation('workspace-one', 0, 'conversation-new'));
+    await firstCreate;
+    expect(useImageWorkspaceStore.getState().creatingConversation).toBe(false);
+  });
 });
diff --git a/tests/unit/local-image-workspace.test.ts b/tests/unit/local-image-workspace.test.ts
index 44fd646..094dd8b 100644
--- a/tests/unit/local-image-workspace.test.ts
+++ b/tests/unit/local-image-workspace.test.ts
@@ -1,4 +1,11 @@
-import { existsSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, describe, expect, it } from 'vitest';
@@ -87,18 +94,96 @@ describe('local AI design workspace', () => {
 
     const reloaded = new LocalImageWorkspace({ userDataDir });
     await expect(reloaded.bootstrap()).resolves.toMatchObject({
-      workspaces: [{ title: '角色设计第二版', turnRevision: 0, viewRevision: 1 }],
+      workspaces: [{ title: '角色设计第二版', conversationCount: 1, viewRevision: 1 }],
     });
   });
 
+  it('migrates a legacy single conversation into schema v3 without losing project tasks', async () => {
+    const userDataDir = createTemporaryDirectory();
+    const rootDirectory = getLocalImageWorkspaceDirectory(userDataDir);
+    const timestamp = '2026-07-31T10:00:00.000Z';
+    mkdirSync(rootDirectory, { recursive: true });
+    writeFileSync(join(rootDirectory, 'design-workspace-v2.json'), JSON.stringify({
+      schemaVersion: 2,
+      workspaces: [{
+        workspaceId: 'workspace-legacy',
+        clientWorkspaceId: 'client-legacy',
+        title: '历史设计项目',
+        turnRevision: 2,
+        viewRevision: 4,
+        phase: 'awaiting_confirmation',
+        brief: {
+          version: 2,
+          status: 'ready',
+          medium: 'image',
+          summary: '历史海报',
+          ready: true,
+          missingDecision: null,
+        },
+        messages: [{
+          id: 'message-legacy',
+          role: 'user',
+          kind: 'user',
+          text: '保留这条历史消息',
+          quickReplies: [],
+          generationQuote: null,
+          turnRevision: 1,
+          createdAt: timestamp,
+        }],
+        requestHashes: { 'turn-legacy': 'hash-legacy' },
+        updatedAt: timestamp,
+      }],
+      tasksByWorkspaceId: {
+        'workspace-legacy': [{
+          taskId: 'task-legacy',
+          workspaceId: 'workspace-legacy',
+          medium: 'image',
+          status: 'succeeded',
+          briefVersion: 2,
+          briefSummary: '历史海报',
+          quoteId: null,
+          quotedDesignPoints: null,
+          failureCode: null,
+          resultAssets: [],
+          createdAt: timestamp,
+          updatedAt: timestamp,
+        }],
+      },
+      assetsById: {},
+    }), 'utf8');
+    const service = createService(userDataDir);
+
+    const workspace = await service.getWorkspace('workspace-legacy');
+    const migratedConversation = workspace.conversations[0];
+
+    expect(workspace).toMatchObject({
+      workspaceId: 'workspace-legacy',
+      conversationCount: 1,
+      conversations: [{ title: '历史会话', turnRevision: 2 }],
+    });
+    await expect(service.getConversation(
+      'workspace-legacy',
+      migratedConversation.conversationId,
+    )).resolves.toMatchObject({
+      messages: [{ text: '保留这条历史消息' }],
+    });
+    await expect(service.listTasks('workspace-legacy')).resolves.toMatchObject([{
+      taskId: 'task-legacy',
+      conversationId: migratedConversation.conversationId,
+    }]);
+    expect(existsSync(join(rootDirectory, 'design-workspace-v3.json'))).toBe(true);
+  });
+
   it('creates a Quote first and a visible generation task only after confirmation', async () => {
     const service = createService(createTemporaryDirectory());
     const created = await service.createWorkspace({
       clientWorkspaceId: 'client-flow',
       title: '海洋公益海报',
     });
+    const conversationId = created.conversations[0].conversationId;
     const discussed = await service.submitMessage({
       workspaceId: created.workspaceId,
+      conversationId,
       clientTurnId: 'turn-one',
       expectedTurnRevision: 0,
       message: '做一张保护海洋的竖版公益海报',
@@ -111,6 +196,7 @@ describe('local AI design workspace', () => {
 
     const confirmed = await service.confirmGeneration({
       workspaceId: created.workspaceId,
+      conversationId,
       clientTurnId: 'turn-two',
       expectedTurnRevision: 1,
       quoteId: quote!.quoteId,
@@ -141,15 +227,17 @@ describe('local AI design workspace', () => {
       clientWorkspaceId: 'client-reset',
       title: '可重置项目',
     });
+    const conversationId = created.conversations[0].conversationId;
 
     await expect(service.submitMessage({
       workspaceId: created.workspaceId,
+      conversationId,
       clientTurnId: 'stale-turn',
       expectedTurnRevision: 3,
       message: '测试',
     })).rejects.toMatchObject<LocalImageWorkspaceError>({
       status: 409,
-      code: 'workspace_revision_conflict',
+      code: 'conversation_revision_conflict',
     });
 
     expect(existsSync(getLocalImageWorkspaceDirectory(userDataDir))).toBe(true);
diff --git a/tests/unit/sidebar-opencode-projects.test.tsx b/tests/unit/sidebar-opencode-projects.test.tsx
index 46e4aa4..de46ad1 100644
--- a/tests/unit/sidebar-opencode-projects.test.tsx
+++ b/tests/unit/sidebar-opencode-projects.test.tsx
@@ -376,8 +376,16 @@ describe('Sidebar project initialization flow', () => {
     const summary = {
       workspaceId: 'cloud-project',
       title: '云端概念设计',
-      turnRevision: 0,
       viewRevision: 0,
+      conversationCount: 1,
+      phase: 'shaping',
+      updatedAt: '2026-07-31T10:00:00Z',
+    };
+    const conversation = {
+      conversationId: 'cloud-conversation',
+      workspaceId: 'cloud-project',
+      title: '主会话',
+      turnRevision: 0,
       phase: 'shaping',
       brief: {
         version: 0,
@@ -387,8 +395,21 @@ describe('Sidebar project initialization flow', () => {
         ready: false,
         missingDecision: '作品形式',
       },
+      createdAt: '2026-07-31T10:00:00Z',
       updatedAt: '2026-07-31T10:00:00Z',
+      messages: [],
     };
+    const { messages: _messages, ...conversationSummary } = conversation;
+    const secondConversation = {
+      ...conversation,
+      conversationId: 'cloud-conversation-two',
+      title: '第二会话',
+      messages: [],
+      createdAt: '2026-07-31T10:05:00Z',
+      updatedAt: '2026-07-31T10:05:00Z',
+    };
+    const { messages: _secondMessages, ...secondConversationSummary } = secondConversation;
+    let hasSecondConversation = false;
     const bootstrap = {
       capabilities: {
         conversation: true,
@@ -403,15 +424,51 @@ describe('Sidebar project initialization flow', () => {
         return { success: true, data: bootstrap };
       }
       if (path === '/api/works/image-workspace/workspaces/cloud-project' && !init?.method) {
-        return { success: true, data: { ...summary, messages: [] } };
+        return {
+          success: true,
+          data: {
+            ...summary,
+            conversationCount: hasSecondConversation ? 2 : 1,
+            conversations: hasSecondConversation
+              ? [secondConversationSummary, conversationSummary]
+              : [conversationSummary],
+          },
+        };
+      }
+      if (path === '/api/works/image-workspace/workspaces/cloud-project/conversations/cloud-conversation') {
+        return { success: true, data: conversation };
+      }
+      if (path === '/api/works/image-workspace/workspaces/cloud-project-two/conversations/cloud-conversation-two') {
+        return {
+          success: true,
+          data: {
+            ...conversation,
+            workspaceId: 'cloud-project-two',
+            conversationId: 'cloud-conversation-two',
+          },
+        };
       }
       if (path === '/api/works/image-workspace/workspaces/cloud-project/tasks') {
         return { success: true, data: [] };
       }
+      if (path === '/api/works/image-workspace/workspaces/cloud-project/conversations'
+        && init?.method === 'POST') {
+        hasSecondConversation = true;
+        return { success: true, data: secondConversation };
+      }
       if (path === '/api/works/image-workspace/workspaces' && init?.method === 'POST') {
         return {
           success: true,
-          data: { ...summary, workspaceId: 'cloud-project-two', title: '角色设定', messages: [] },
+          data: {
+            ...summary,
+            workspaceId: 'cloud-project-two',
+            title: '角色设定',
+            conversations: [{
+              ...conversationSummary,
+              workspaceId: 'cloud-project-two',
+              conversationId: 'cloud-conversation-two',
+            }],
+          },
         };
       }
       throw new Error(`Unexpected path ${path}`);
@@ -428,6 +485,19 @@ describe('Sidebar project initialization flow', () => {
     expect(screen.queryByText('项目模板')).not.toBeInTheDocument();
     expect(hostApiFetchMock.mock.calls.some(([path]) => path === '/api/opencode/projects')).toBe(false);
     expect(screen.queryByText(/添加 Agent/)).not.toBeInTheDocument();
+    expect(screen.getByTestId('sidebar-image-conversation-cloud-conversation'))
+      .toHaveAttribute('aria-current', 'page');
+
+    fireEvent.click(screen.getByRole('button', { name: '新建设计会话' }));
+    await waitFor(() => expect(hostApiFetchMock).toHaveBeenCalledWith(
+      '/api/works/image-workspace/workspaces/cloud-project/conversations',
+      expect.objectContaining({ method: 'POST' }),
+    ));
+    expect(await screen.findByTestId('sidebar-image-conversation-cloud-conversation-two'))
+      .toHaveAttribute('aria-current', 'page');
+    fireEvent.click(screen.getByTestId('sidebar-image-conversation-cloud-conversation'));
+    await waitFor(() => expect(screen.getByTestId('sidebar-image-conversation-cloud-conversation'))
+      .toHaveAttribute('aria-current', 'page'));
 
     fireEvent.click(screen.getByTestId('sidebar-create-image-project'));
     expect(screen.getByRole('dialog', { name: '新建设计项目' })).toBeInTheDocument();
@@ -456,8 +526,16 @@ describe('Sidebar project initialization flow', () => {
     const summary = {
       workspaceId: 'local-project',
       title: '概念设计',
-      turnRevision: 0,
       viewRevision: 0,
+      conversationCount: 1,
+      phase: 'shaping',
+      updatedAt: '2026-07-31T10:00:00Z',
+    };
+    const conversation = {
+      conversationId: 'local-conversation',
+      workspaceId: 'local-project',
+      title: '主会话',
+      turnRevision: 0,
       phase: 'shaping',
       brief: {
         version: 0,
@@ -467,8 +545,11 @@ describe('Sidebar project initialization flow', () => {
         ready: false,
         missingDecision: '作品形式',
       },
+      createdAt: '2026-07-31T10:00:00Z',
       updatedAt: '2026-07-31T10:00:00Z',
+      messages: [],
     };
+    const { messages: _messages, ...conversationSummary } = conversation;
     let bootstrap = {
       capabilities: {
         conversation: true,
@@ -483,7 +564,10 @@ describe('Sidebar project initialization flow', () => {
         return { success: true, data: bootstrap };
       }
       if (path === '/api/works/image-workspace/workspaces/local-project' && !init?.method) {
-        return { success: true, data: { ...summary, messages: [] } };
+        return { success: true, data: { ...summary, conversations: [conversationSummary] } };
+      }
+      if (path === '/api/works/image-workspace/workspaces/local-project/conversations/local-conversation') {
+        return { success: true, data: conversation };
       }
       if (path === '/api/works/image-workspace/workspaces/local-project/tasks') {
         return { success: true, data: [] };
@@ -493,11 +577,25 @@ describe('Sidebar project initialization flow', () => {
           ...summary,
           workspaceId: 'local-project-two',
           title: '角色设计',
-          messages: [],
+          conversations: [{
+            ...conversationSummary,
+            workspaceId: 'local-project-two',
+            conversationId: 'local-conversation-two',
+          }],
         };
         bootstrap = { ...bootstrap, workspaces: [created, ...bootstrap.workspaces] };
         return { success: true, data: created };
       }
+      if (path === '/api/works/image-workspace/workspaces/local-project-two/conversations/local-conversation-two') {
+        return {
+          success: true,
+          data: {
+            ...conversation,
+            workspaceId: 'local-project-two',
+            conversationId: 'local-conversation-two',
+          },
+        };
+      }
       throw new Error(`Unexpected path ${path}`);
     });
 
diff --git a/tests/unit/works-square-design-workspace.test.ts b/tests/unit/works-square-design-workspace.test.ts
index 67a5b0f..528e26b 100644
--- a/tests/unit/works-square-design-workspace.test.ts
+++ b/tests/unit/works-square-design-workspace.test.ts
@@ -9,37 +9,48 @@ vi.mock('@electron/services/works-square-session', () => ({
 
 const getTokenMock = vi.mocked(getValidWorksSquareAccessToken);
 
-const serverWorkspace = {
+const serverConversation = {
+  conversation_id: 'conversation-one',
   workspace_id: 'workspace-one',
-  title: '海洋公益海报',
+  agent_session_id: 'session-one',
+  title: '????',
   turn_revision: 1,
-  view_revision: 2,
   phase: 'awaiting_confirmation',
   brief: {
     version: 1,
     status: 'ready',
     medium: 'image',
-    summary: '保护海洋的竖版公益海报',
+    summary: '???????????',
     ready: true,
     missing_decision: null,
   },
   messages: [{
     role: 'assistant',
     kind: 'confirmation',
-    text: '方向已经明确，是否开始生成？',
-    quick_replies: ['确认生成'],
+    text: '??????????????',
+    quick_replies: ['????'],
     generation_quote: {
       quote_id: 'quote-one',
       status: 'active',
       medium: 'image',
       brief_version: 1,
-      brief_summary: '保护海洋的竖版公益海报',
+      brief_summary: '???????????',
       quoted_design_points: 1,
       expires_at: '2026-07-31T11:00:00Z',
     },
     turn_revision: 1,
     created_at: '2026-07-31T10:00:00Z',
   }],
+  created_at: '2026-07-31T10:00:00Z',
+  updated_at: '2026-07-31T10:00:00Z',
+};
+
+const serverWorkspace = {
+  workspace_id: 'workspace-one',
+  title: '??????',
+  view_revision: 2,
+  conversation_count: 1,
+  phase: 'awaiting_confirmation',
   updated_at: '2026-07-31T10:00:00Z',
 };
 
@@ -148,10 +159,9 @@ describe('Works Square AI design adapter', () => {
       capabilities: { conversation: true, image: true, video: false },
       workspaces: [{
         workspaceId: 'workspace-one',
-        title: '海洋公益海报',
-        turnRevision: 1,
+        title: '??????',
         viewRevision: 2,
-        brief: { missingDecision: null },
+        conversationCount: 1,
       }],
     });
     expect(fetchMock).toHaveBeenCalledTimes(2);
@@ -160,12 +170,71 @@ describe('Works Square AI design adapter', () => {
     ))).toBe(true);
   });
 
+  it('lists, creates, and reads Conversations through the Workspace API', async () => {
+    const secondConversation = {
+      ...serverConversation,
+      conversation_id: 'conversation-two',
+      agent_session_id: 'session-two',
+      title: '第二会话',
+    };
+    const fetchMock = vi.fn<typeof fetch>()
+      .mockResolvedValueOnce(jsonResponse(serverWorkspace))
+      .mockResolvedValueOnce(jsonResponse([serverConversation]))
+      .mockResolvedValueOnce(jsonResponse(secondConversation, 201))
+      .mockResolvedValueOnce(jsonResponse(secondConversation));
+    const adapter = new WorksSquareDesignWorkspace({
+      apiBaseUrl: 'https://square.example',
+      fetchImpl: fetchMock,
+    });
+
+    await expect(adapter.getWorkspace('workspace-one')).resolves.toMatchObject({
+      workspaceId: 'workspace-one',
+      conversationCount: 1,
+      conversations: [{ conversationId: 'conversation-one' }],
+    });
+    await expect(adapter.createConversation({
+      workspaceId: 'workspace-one',
+      clientConversationId: 'client-conversation-two',
+      title: '第二会话',
+    })).resolves.toMatchObject({
+      workspaceId: 'workspace-one',
+      conversationId: 'conversation-two',
+      title: '第二会话',
+    });
+    await expect(adapter.getConversation('workspace-one', 'conversation-two'))
+      .resolves.toMatchObject({ conversationId: 'conversation-two' });
+
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      1,
+      'https://square.example/api/design/workspaces/workspace-one',
+      expect.objectContaining({ headers: expect.any(Object) }),
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      2,
+      'https://square.example/api/design/workspaces/workspace-one/conversations?limit=100&offset=0',
+      expect.objectContaining({ headers: expect.any(Object) }),
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      3,
+      'https://square.example/api/design/workspaces/workspace-one/conversations',
+      expect.objectContaining({
+        method: 'POST',
+        body: JSON.stringify({
+          client_conversation_id: 'client-conversation-two',
+          title: '第二会话',
+        }),
+      }),
+    );
+    expect(fetchMock).toHaveBeenNthCalledWith(
+      4,
+      'https://square.example/api/design/workspaces/workspace-one/conversations/conversation-two',
+      expect.objectContaining({ headers: expect.any(Object) }),
+    );
+  });
+
   it('submits a conversation turn through the persistent Agent Gateway Session', async () => {
     const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({
-        session_id: 'session-one',
-        status: 'active',
-      }, 201))
+      .mockResolvedValueOnce(jsonResponse(serverConversation))
       .mockResolvedValueOnce(jsonResponse({
         run_id: 'run-one',
         status: 'queued',
@@ -176,7 +245,7 @@ describe('Works Square AI design adapter', () => {
         status: 'succeeded',
         error: null,
       }))
-      .mockResolvedValueOnce(jsonResponse(serverWorkspace));
+      .mockResolvedValueOnce(jsonResponse(serverConversation));
     const adapter = new WorksSquareDesignWorkspace({
       apiBaseUrl: 'https://square.example',
       fetchImpl: fetchMock,
@@ -185,9 +254,10 @@ describe('Works Square AI design adapter', () => {
 
     await expect(adapter.submitMessage({
       workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
       clientTurnId: 'turn-two',
       expectedTurnRevision: 1,
-      message: '做一张保护海洋的公益海报',
+      message: '????????????',
       attachmentAssetIds: ['asset-reference'],
     })).resolves.toMatchObject({
       workspaceId: 'workspace-one',
@@ -204,7 +274,7 @@ describe('Works Square AI design adapter', () => {
           name: 'turn.submit',
           input: {
             expected_turn_revision: 1,
-            message: '做一张保护海洋的公益海报',
+            message: '????????????',
             attachment_asset_ids: ['asset-reference'],
             action: null,
           },
@@ -218,9 +288,11 @@ describe('Works Square AI design adapter', () => {
     );
     expect(fetchMock).toHaveBeenNthCalledWith(
       4,
-      'https://square.example/api/design/workspaces/workspace-one',
+      'https://square.example/api/design/workspaces/workspace-one/conversations/conversation-one',
       expect.objectContaining({ headers: expect.any(Object) }),
     );
+    const commandBody = JSON.parse(String(fetchMock.mock.calls[1][1]?.body));
+    expect(commandBody.input).not.toHaveProperty('conversation_id');
   });
 
   it('uploads a local reference image as multipart data and maps the returned Asset', async () => {
@@ -267,8 +339,8 @@ describe('Works Square AI design adapter', () => {
     const { sockets, webSocketFactory } = scriptedSockets([{ open: true }]);
     const fetchMock = vi.fn<typeof fetch>(async (input) => {
       const url = String(input);
-      if (url.endsWith('/api/agents/sessions')) {
-        return jsonResponse({ session_id: 'session-live', status: 'active' }, 201);
+      if (url.endsWith('/conversations/conversation-one')) {
+        return jsonResponse({ ...serverConversation, agent_session_id: 'session-live' });
       }
       if (url.endsWith('/stream-tickets')) {
         return jsonResponse({
@@ -301,8 +373,8 @@ describe('Works Square AI design adapter', () => {
           status: 'accepted',
         }, 202);
       }
-      if (url.endsWith('/api/design/workspaces/workspace-one')) {
-        return jsonResponse(serverWorkspace);
+      if (url.endsWith('/conversations/conversation-one')) {
+        return jsonResponse(serverConversation);
       }
       throw new Error(`Unexpected request: ${url}`);
     });
@@ -311,14 +383,15 @@ describe('Works Square AI design adapter', () => {
       fetchImpl: fetchMock,
       webSocketFactory,
     });
-    const subscription = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
+    const subscription = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one', conversationId: 'conversation-one' });
 
     try {
       await expect(adapter.submitMessage({
         workspaceId: 'workspace-one',
+        conversationId: 'conversation-one',
         clientTurnId: 'turn-live',
         expectedTurnRevision: 1,
-        message: '做一张保护海洋的公益海报',
+        message: '????????????',
       })).resolves.toMatchObject({ workspaceId: 'workspace-one' });
       expect(fetchMock.mock.calls.filter(([url]) => String(url).includes('/runs/'))).toHaveLength(0);
     } finally {
@@ -328,15 +401,15 @@ describe('Works Square AI design adapter', () => {
 
   it('does not let terminal Run completion overtake streamed design events', async () => {
     const { sockets, webSocketFactory } = scriptedSockets([{ open: true }]);
-    const streamedWorkspace = {
-      ...serverWorkspace,
+    const streamedConversation = {
+      ...serverConversation,
+      agent_session_id: 'session-ordered',
       turn_revision: 2,
-      view_revision: 3,
     };
     const fetchMock = vi.fn<typeof fetch>(async (input) => {
       const url = String(input);
-      if (url.endsWith('/api/agents/sessions')) {
-        return jsonResponse({ session_id: 'session-ordered', status: 'active' }, 201);
+      if (url.endsWith('/conversations/conversation-one')) {
+        return jsonResponse(streamedConversation);
       }
       if (url.endsWith('/stream-tickets')) {
         return jsonResponse({
@@ -356,10 +429,11 @@ describe('Works Square AI design adapter', () => {
               schema_version: 1,
               payload: {
                 workspace_id: 'workspace-one',
+                conversation_id: 'conversation-one',
                 client_turn_id: 'turn-ordered',
                 turn_revision: 2,
                 chunk_index: 0,
-                delta: '先看见这一段',
+                delta: '??????',
               },
             },
           });
@@ -369,11 +443,14 @@ describe('Works Square AI design adapter', () => {
               session_id: 'session-ordered',
               sequence: 5,
               runtime: 'design',
-              type: 'design.workspace.updated',
+              type: 'design.conversation.updated',
               run_id: 'run-ordered',
               schema_version: 1,
               payload: {
-                workspace: streamedWorkspace,
+                workspace_id: 'workspace-one',
+                conversation_id: 'conversation-one',
+                workspace_view_revision: 3,
+                conversation: streamedConversation,
                 generation_tasks: [],
               },
             },
@@ -393,9 +470,6 @@ describe('Works Square AI design adapter', () => {
         });
         return jsonResponse({ run_id: 'run-ordered', status: 'queued', error: null }, 202);
       }
-      if (url.endsWith('/api/design/workspaces/workspace-one')) {
-        return jsonResponse(streamedWorkspace);
-      }
       throw new Error(`Unexpected request: ${url}`);
     });
     const adapter = new WorksSquareDesignWorkspace({
@@ -403,7 +477,7 @@ describe('Works Square AI design adapter', () => {
       fetchImpl: fetchMock,
       webSocketFactory,
     });
-    const subscription = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
+    const subscription = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one', conversationId: 'conversation-one' });
     const releaseFirstWrite = deferred<void>();
     const received: DesignWorkspaceEvent[] = [];
     const consume = (async () => {
@@ -418,9 +492,10 @@ describe('Works Square AI design adapter', () => {
     try {
       const turn = adapter.submitMessage({
         workspaceId: 'workspace-one',
+        conversationId: 'conversation-one',
         clientTurnId: 'turn-ordered',
         expectedTurnRevision: 1,
-        message: '让回复逐步出现',
+        message: '???????',
       }).finally(() => {
         resolved = true;
       });
@@ -429,19 +504,19 @@ describe('Works Square AI design adapter', () => {
       await new Promise<void>((resolve) => setTimeout(resolve, 0));
       expect(received[0]).toMatchObject({
         type: 'design.assistant.delta',
-        delta: '先看见这一段',
+        delta: '??????',
       });
       expect(resolved).toBe(false);
-      expect(fetchMock.mock.calls.some(([url]) => (
-        String(url).endsWith('/api/design/workspaces/workspace-one')
-      ))).toBe(false);
+      expect(fetchMock.mock.calls.filter(([url]) => (
+        String(url).endsWith('/conversations/conversation-one')
+      ))).toHaveLength(1);
 
       releaseFirstWrite.resolve();
       await consume;
       await expect(turn).resolves.toMatchObject({ turnRevision: 2 });
       expect(received.map((event) => event.type)).toEqual([
         'design.assistant.delta',
-        'design.generation_tasks.snapshot',
+        'design.conversation.snapshot',
       ]);
     } finally {
       releaseFirstWrite.resolve();
@@ -452,15 +527,15 @@ describe('Works Square AI design adapter', () => {
   it('bounds the delivery barrier when an opened stream has no consumer', async () => {
     vi.useFakeTimers();
     const { sockets, webSocketFactory } = scriptedSockets([{ open: true }]);
-    const streamedWorkspace = {
-      ...serverWorkspace,
+    const streamedConversation = {
+      ...serverConversation,
+      agent_session_id: 'session-bounded',
       turn_revision: 2,
-      view_revision: 3,
     };
     const fetchMock = vi.fn<typeof fetch>(async (input) => {
       const url = String(input);
-      if (url.endsWith('/api/agents/sessions')) {
-        return jsonResponse({ session_id: 'session-bounded', status: 'active' }, 201);
+      if (url.endsWith('/conversations/conversation-one')) {
+        return jsonResponse(streamedConversation);
       }
       if (url.endsWith('/stream-tickets')) {
         return jsonResponse({
@@ -475,10 +550,16 @@ describe('Works Square AI design adapter', () => {
               session_id: 'session-bounded',
               sequence: 5,
               runtime: 'design',
-              type: 'design.workspace.updated',
+              type: 'design.conversation.updated',
               run_id: 'run-bounded',
               schema_version: 1,
-              payload: { workspace: streamedWorkspace, generation_tasks: [] },
+              payload: {
+                workspace_id: 'workspace-one',
+                conversation_id: 'conversation-one',
+                workspace_view_revision: 3,
+                conversation: streamedConversation,
+                generation_tasks: [],
+              },
             },
           });
           sockets[0]?.emitFrame({
@@ -496,9 +577,6 @@ describe('Works Square AI design adapter', () => {
         });
         return jsonResponse({ run_id: 'run-bounded', status: 'queued', error: null }, 202);
       }
-      if (url.endsWith('/api/design/workspaces/workspace-one')) {
-        return jsonResponse(streamedWorkspace);
-      }
       throw new Error(`Unexpected request: ${url}`);
     });
     const adapter = new WorksSquareDesignWorkspace({
@@ -506,7 +584,7 @@ describe('Works Square AI design adapter', () => {
       fetchImpl: fetchMock,
       webSocketFactory,
     });
-    const subscriptionPromise = adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
+    const subscriptionPromise = adapter.openWorkspaceEvents({ workspaceId: 'workspace-one', conversationId: 'conversation-one' });
     await vi.advanceTimersByTimeAsync(0);
     const subscription = await subscriptionPromise;
     let resolved = false;
@@ -514,9 +592,10 @@ describe('Works Square AI design adapter', () => {
     try {
       const turn = adapter.submitMessage({
         workspaceId: 'workspace-one',
+        conversationId: 'conversation-one',
         clientTurnId: 'turn-bounded',
         expectedTurnRevision: 1,
-        message: '即使页面暂停消费也不能永久等待',
+        message: '???????????????',
       }).finally(() => {
         resolved = true;
       });
@@ -537,8 +616,8 @@ describe('Works Square AI design adapter', () => {
     const { sockets, webSocketFactory } = scriptedSockets([{ open: true }]);
     const fetchMock = vi.fn<typeof fetch>(async (input) => {
       const url = String(input);
-      if (url.endsWith('/api/agents/sessions')) {
-        return jsonResponse({ session_id: 'session-failed', status: 'active' }, 201);
+      if (url.endsWith('/conversations/conversation-one')) {
+        return jsonResponse({ ...serverConversation, agent_session_id: 'session-failed' });
       }
       if (url.endsWith('/stream-tickets')) {
         return jsonResponse({
@@ -573,11 +652,12 @@ describe('Works Square AI design adapter', () => {
       fetchImpl: fetchMock,
       webSocketFactory,
     });
-    const subscription = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
+    const subscription = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one', conversationId: 'conversation-one' });
 
     try {
       await expect(adapter.submitMessage({
         workspaceId: 'workspace-one',
+        conversationId: 'conversation-one',
         clientTurnId: 'turn-failed',
         expectedTurnRevision: 1,
         message: 'invalid',
@@ -595,7 +675,10 @@ describe('Works Square AI design adapter', () => {
   it('falls back to one Run request after the WebSocket disconnects', async () => {
     const { webSocketFactory } = scriptedSockets([{ open: true, closeCode: 1006 }]);
     const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-fallback', status: 'active' }, 201))
+      .mockResolvedValueOnce(jsonResponse({
+        ...serverConversation,
+        agent_session_id: 'session-fallback',
+      }))
       .mockResolvedValueOnce(jsonResponse({
         stream_url: '/api/agents/sessions/session-fallback/ws?ticket=ticket-fallback',
       }))
@@ -609,20 +692,21 @@ describe('Works Square AI design adapter', () => {
         status: 'succeeded',
         error: null,
       }))
-      .mockResolvedValueOnce(jsonResponse(serverWorkspace));
+      .mockResolvedValueOnce(jsonResponse(serverConversation));
     const adapter = new WorksSquareDesignWorkspace({
       apiBaseUrl: 'https://square.example',
       fetchImpl: fetchMock,
       webSocketFactory,
     });
-    const subscription = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
+    const subscription = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one', conversationId: 'conversation-one' });
 
     try {
       await expect(adapter.submitMessage({
         workspaceId: 'workspace-one',
+        conversationId: 'conversation-one',
         clientTurnId: 'turn-fallback',
         expectedTurnRevision: 1,
-        message: '断线后继续完成',
+        message: '???????',
       })).resolves.toMatchObject({ workspaceId: 'workspace-one' });
       expect(fetchMock.mock.calls.filter(([url]) => String(url).includes('/runs/'))).toHaveLength(1);
     } finally {
@@ -637,8 +721,8 @@ describe('Works Square AI design adapter', () => {
     let runPolls = 0;
     const fetchMock = vi.fn<typeof fetch>(async (input, init) => {
       const url = String(input);
-      if (url.endsWith('/api/agents/sessions')) {
-        return jsonResponse({ session_id: 'session-slow', status: 'active' }, 201);
+      if (url.endsWith('/conversations/conversation-one')) {
+        return jsonResponse({ ...serverConversation, agent_session_id: 'session-slow' });
       }
       if (url.endsWith('/api/agents/sessions/session-slow/commands')) {
         return jsonResponse({ run_id: 'run-slow', status: 'queued', error: null }, 202);
@@ -651,8 +735,8 @@ describe('Works Square AI design adapter', () => {
           error: null,
         });
       }
-      if (url.endsWith('/api/design/workspaces/workspace-one')) {
-        return jsonResponse(serverWorkspace);
+      if (url.endsWith('/conversations/conversation-one')) {
+        return jsonResponse(serverConversation);
       }
       throw new Error(`Unexpected request: ${url} ${init?.method ?? 'GET'}`);
     });
@@ -664,9 +748,10 @@ describe('Works Square AI design adapter', () => {
     try {
       const outcomePromise = adapter.submitMessage({
         workspaceId: 'workspace-one',
+        conversationId: 'conversation-one',
         clientTurnId: 'turn-slow',
         expectedTurnRevision: 1,
-        message: '整理一个复杂的品牌设计方向',
+        message: '?????????????',
       }).then(
         (value) => ({ value, error: null }),
         (error: unknown) => ({ value: null, error }),
@@ -685,10 +770,7 @@ describe('Works Square AI design adapter', () => {
 
   it('maps an invalid Runtime command to a user input error', async () => {
     const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({
-        session_id: 'session-one',
-        status: 'active',
-      }, 201))
+      .mockResolvedValueOnce(jsonResponse(serverConversation))
       .mockResolvedValueOnce(jsonResponse({
         run_id: 'run-invalid',
         status: 'queued',
@@ -710,6 +792,7 @@ describe('Works Square AI design adapter', () => {
 
     await expect(adapter.submitMessage({
       workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
       clientTurnId: 'turn-invalid',
       expectedTurnRevision: 1,
       message: 'invalid',
@@ -722,10 +805,7 @@ describe('Works Square AI design adapter', () => {
 
   it('keeps task creation behind structured Quote confirmation', async () => {
     const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({
-        session_id: 'session-one',
-        status: 'active',
-      }, 201))
+      .mockResolvedValueOnce(jsonResponse(serverConversation))
       .mockResolvedValueOnce(jsonResponse({
         run_id: 'run-confirm',
         status: 'queued',
@@ -736,7 +816,7 @@ describe('Works Square AI design adapter', () => {
         status: 'succeeded',
         error: null,
       }))
-      .mockResolvedValueOnce(jsonResponse(serverWorkspace));
+      .mockResolvedValueOnce(jsonResponse(serverConversation));
     const adapter = new WorksSquareDesignWorkspace({
       apiBaseUrl: 'https://square.example/',
       fetchImpl: fetchMock,
@@ -744,6 +824,7 @@ describe('Works Square AI design adapter', () => {
 
     const workspace = await adapter.confirmGeneration({
       workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
       clientTurnId: 'turn-two',
       expectedTurnRevision: 1,
       quoteId: 'quote-one',
@@ -774,7 +855,7 @@ describe('Works Square AI design adapter', () => {
     );
     expect(fetchMock).toHaveBeenNthCalledWith(
       4,
-      'https://square.example/api/design/workspaces/workspace-one',
+      'https://square.example/api/design/workspaces/workspace-one/conversations/conversation-one',
       expect.objectContaining({ headers: expect.any(Object) }),
     );
   });
@@ -786,7 +867,7 @@ describe('Works Square AI design adapter', () => {
       medium: 'image',
       status: 'succeeded',
       brief_version: 1,
-      brief_summary: '海洋公益海报',
+      brief_summary: '??????',
       quote_id: 'quote-one',
       quoted_design_points: 1,
       failure_code: null,
@@ -877,10 +958,13 @@ describe('Works Square AI design adapter', () => {
       session_id: 'session-one',
       sequence: 1,
       runtime: 'design',
-      type: 'design.workspace.updated',
+      type: 'design.conversation.updated',
       schema_version: 1,
       payload: {
-        workspace: serverWorkspace,
+        workspace_id: 'workspace-one',
+        conversation_id: 'conversation-one',
+        workspace_view_revision: 2,
+        conversation: serverConversation,
         generation_tasks: [snapshotTask],
       },
     };
@@ -892,10 +976,11 @@ describe('Works Square AI design adapter', () => {
       schema_version: 1,
       payload: {
         workspace_id: 'workspace-one',
+        conversation_id: 'conversation-one',
         client_turn_id: 'turn-two',
         turn_revision: 2,
         chunk_index: 0,
-        delta: '方向已经明确',
+        delta: '??????',
       },
     };
     const malformedDeltaEvent = {
@@ -926,7 +1011,7 @@ describe('Works Square AI design adapter', () => {
           medium: 'video',
           status: 'running',
           brief_version: 2,
-          brief_summary: '海洋公益短片',
+          brief_summary: '??????',
           quote_id: 'quote-live',
           quoted_design_points: 8,
           failure_code: null,
@@ -937,10 +1022,7 @@ describe('Works Square AI design adapter', () => {
       },
     };
     const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({
-        session_id: 'session-one',
-        status: 'active',
-      }, 201))
+      .mockResolvedValueOnce(jsonResponse(serverConversation))
       .mockResolvedValueOnce(jsonResponse({
         ticket: 'secret-ticket-one',
         transport: 'websocket',
@@ -971,12 +1053,13 @@ describe('Works Square AI design adapter', () => {
       webSocketFactory,
     });
 
-    const first = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
+    const first = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one', conversationId: 'conversation-one' });
     const received = [];
     for await (const event of first.events) received.push(event);
     first.close();
     const second = await adapter.openWorkspaceEvents({
       workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
       afterEventId: 'session-one:3',
     });
     for await (const _event of second.events) {
@@ -987,14 +1070,15 @@ describe('Works Square AI design adapter', () => {
     expect(received).toEqual([
       {
         id: 'session-one:1',
-        type: 'design.generation_tasks.snapshot',
+        type: 'design.conversation.snapshot',
         workspaceId: 'workspace-one',
+        conversationId: 'conversation-one',
         workspaceViewRevision: 2,
-        workspace: expect.objectContaining({
-          workspaceId: 'workspace-one',
-          title: serverWorkspace.title,
+        conversation: expect.objectContaining({
+          conversationId: 'conversation-one',
+          title: serverConversation.title,
           messages: [expect.objectContaining({
-            text: serverWorkspace.messages[0].text,
+            text: serverConversation.messages[0].text,
           })],
         }),
         generationTasks: [expect.objectContaining({
@@ -1007,10 +1091,11 @@ describe('Works Square AI design adapter', () => {
         id: 'session-one:2',
         type: 'design.assistant.delta',
         workspaceId: 'workspace-one',
+        conversationId: 'conversation-one',
         clientTurnId: 'turn-two',
         turnRevision: 2,
         chunkIndex: 0,
-        delta: '方向已经明确',
+        delta: '??????',
       },
       {
         id: 'session-one:3',
@@ -1026,13 +1111,12 @@ describe('Works Square AI design adapter', () => {
     ]);
     expect(fetchMock).toHaveBeenNthCalledWith(
       1,
-      'https://square.example/api/agents/sessions',
-      expect.objectContaining({
-        method: 'POST',
-        body: expect.stringContaining('"runtime":"design"'),
-      }),
+      'https://square.example/api/design/workspaces/workspace-one/conversations/conversation-one',
+      expect.objectContaining({ headers: expect.any(Object) }),
     );
-    expect(fetchMock.mock.calls.filter(([url]) => String(url).endsWith('/api/agents/sessions')))
+    expect(fetchMock.mock.calls.filter(([url]) => (
+      String(url).endsWith('/conversations/conversation-one')
+    )))
       .toHaveLength(1);
     expect(fetchMock.mock.calls.filter(([url]) => String(url).endsWith('/stream-tickets')))
       .toHaveLength(2);
@@ -1048,17 +1132,13 @@ describe('Works Square AI design adapter', () => {
     ]);
   });
 
-  it('rotates the Session and client id after an upstream event cursor expires', async () => {
-    const rotate = vi.fn().mockResolvedValue('design-stream-next');
+  it('reloads the persistent Conversation Session after an upstream event cursor expires', async () => {
     const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-old', status: 'active' }, 201))
+      .mockResolvedValueOnce(jsonResponse({ ...serverConversation, agent_session_id: 'session-old' }))
       .mockResolvedValueOnce(jsonResponse({
         stream_url: '/api/agents/sessions/session-old/ws?ticket=ticket-old',
       }))
-      .mockResolvedValueOnce(jsonResponse({
-        session_id: 'session-old', status: 'closed',
-      }))
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-new', status: 'active' }, 201))
+      .mockResolvedValueOnce(jsonResponse({ ...serverConversation, agent_session_id: 'session-new' }))
       .mockResolvedValueOnce(jsonResponse({
         stream_url: '/api/agents/sessions/session-new/ws?ticket=ticket-new',
       }));
@@ -1070,48 +1150,39 @@ describe('Works Square AI design adapter', () => {
       apiBaseUrl: 'https://square.example',
       fetchImpl: fetchMock,
       webSocketFactory,
-      eventSessionClientIdStore: {
-        getOrCreate: vi.fn().mockResolvedValue('design-stream-current'),
-        rotate,
-      },
     });
 
     await expect(adapter.openWorkspaceEvents({
       workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
       afterEventId: 'session-old:99',
     })).rejects.toMatchObject({ status: 410 });
     const recovered = await adapter.openWorkspaceEvents({
       workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
       afterEventId: 'session-old:99',
     });
     for await (const _event of recovered.events) {
       // Empty recovery stream.
     }
 
-    const sessionCalls = fetchMock.mock.calls.filter(([url]) => (
-      String(url).endsWith('/api/agents/sessions')
-    ));
-    expect(sessionCalls).toHaveLength(2);
-    expect(JSON.parse(String(sessionCalls[0][1]?.body)).client_session_id)
-      .not.toBe(JSON.parse(String(sessionCalls[1][1]?.body)).client_session_id);
-    expect(rotate).toHaveBeenCalledWith('workspace-one');
-    expect(fetchMock.mock.calls[2]).toEqual([
-      'https://square.example/api/agents/sessions/session-old',
-      expect.objectContaining({ method: 'DELETE' }),
-    ]);
+    expect(fetchMock.mock.calls.filter(([url]) => (
+      String(url).endsWith('/conversations/conversation-one')
+    ))).toHaveLength(2);
+    expect(fetchMock.mock.calls.some(([, init]) => init?.method === 'DELETE')).toBe(false);
     expect(sockets.map((socket) => socket.url)).toEqual([
       'wss://square.example/api/agents/sessions/session-old/ws?ticket=ticket-old&after_sequence=99',
       'wss://square.example/api/agents/sessions/session-new/ws?ticket=ticket-new&after_sequence=0',
     ]);
   });
 
-  it('replaces a closed cached Session before opening the task stream', async () => {
+  it('refreshes a closed persistent Session before opening the task stream', async () => {
     const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-old', status: 'active' }, 201))
+      .mockResolvedValueOnce(jsonResponse({ ...serverConversation, agent_session_id: 'session-old' }))
       .mockResolvedValueOnce(jsonResponse({
-        detail: { code: 'agent_session_closed', message: 'closed' },
+        code: 'agent_session_closed', message: 'closed',
       }, 409))
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-new', status: 'active' }, 201))
+      .mockResolvedValueOnce(jsonResponse({ ...serverConversation, agent_session_id: 'session-new' }))
       .mockResolvedValueOnce(jsonResponse({
         stream_url: '/api/agents/sessions/session-new/ws?ticket=ticket-new',
       }));
@@ -1122,35 +1193,36 @@ describe('Works Square AI design adapter', () => {
       webSocketFactory,
     });
 
-    const recovered = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
+    const recovered = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one', conversationId: 'conversation-one' });
     for await (const _event of recovered.events) {
       // Empty recovery stream.
     }
 
-    const sessionCalls = fetchMock.mock.calls.filter(([url]) => (
-      String(url).endsWith('/api/agents/sessions')
-    ));
-    expect(sessionCalls).toHaveLength(2);
-    expect(JSON.parse(String(sessionCalls[0][1]?.body)).client_session_id)
-      .not.toBe(JSON.parse(String(sessionCalls[1][1]?.body)).client_session_id);
+    expect(fetchMock.mock.calls.filter(([url]) => (
+      String(url).endsWith('/conversations/conversation-one')
+    ))).toHaveLength(2);
+    expect(fetchMock.mock.calls.filter(([url]) => String(url).endsWith('/stream-tickets')))
+      .toHaveLength(2);
   });
 
-  it('closes every cached Agent Session during logout or application shutdown', async () => {
+  it('closes active local streams without deleting persistent Agent Sessions', async () => {
     const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-one', status: 'active' }, 201))
+      .mockResolvedValueOnce(jsonResponse(serverConversation))
       .mockResolvedValueOnce(jsonResponse({
         stream_url: '/api/agents/sessions/session-one/ws?ticket=ticket-one',
       }))
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-two', status: 'active' }, 201))
+      .mockResolvedValueOnce(jsonResponse({
+        ...serverConversation,
+        workspace_id: 'workspace-two',
+        conversation_id: 'conversation-two',
+        agent_session_id: 'session-two',
+      }))
       .mockResolvedValueOnce(jsonResponse({
         stream_url: '/api/agents/sessions/session-two/ws?ticket=ticket-two',
-      }))
-      .mockImplementation(() => Promise.resolve(
-        jsonResponse({ session_id: 'closed', status: 'closed' }),
-      ));
-    const { webSocketFactory } = scriptedSockets([
-      { closeCode: 1000 },
-      { closeCode: 1000 },
+      }));
+    const { sockets, webSocketFactory } = scriptedSockets([
+      { open: true },
+      { open: true },
     ]);
     const adapter = new WorksSquareDesignWorkspace({
       apiBaseUrl: 'https://square.example',
@@ -1158,129 +1230,129 @@ describe('Works Square AI design adapter', () => {
       webSocketFactory,
     });
 
-    const first = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
-    for await (const _event of first.events) {
-      // Empty stream.
-    }
-    const second = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-two' });
-    for await (const _event of second.events) {
-      // Empty stream.
-    }
+    const first = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one', conversationId: 'conversation-one' });
+    const second = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-two', conversationId: 'conversation-two' });
     await adapter.closeEventSessions();
 
     const closeCalls = fetchMock.mock.calls.filter(([, init]) => init?.method === 'DELETE');
-    expect(closeCalls.map(([url]) => String(url)).sort()).toEqual([
-      'https://square.example/api/agents/sessions/session-one',
-      'https://square.example/api/agents/sessions/session-two',
+    expect(closeCalls).toHaveLength(0);
+    expect(sockets.map((socket) => socket.readyState)).toEqual([3, 3]);
+    first.close();
+    second.close();
+  });
+
+  it('reloads persistent Session ids after local event sessions are closed', async () => {
+    const fetchMock = vi.fn<typeof fetch>(async (input) => {
+      const url = String(input);
+      if (url.endsWith('/api/design/capabilities')) {
+        return jsonResponse({
+          conversation: true,
+          generation: true,
+          image: true,
+          video: false,
+        });
+      }
+      if (url.endsWith('/api/design/workspaces?limit=100&offset=0')) {
+        return jsonResponse([]);
+      }
+      if (url.endsWith('/conversations/conversation-one')) {
+        return jsonResponse(serverConversation);
+      }
+      if (url.endsWith('/stream-tickets')) {
+        return jsonResponse({
+          stream_url: '/api/agents/sessions/session-one/ws?ticket=ticket-one',
+        });
+      }
+      return jsonResponse({ detail: { code: 'unexpected_request', message: url } }, 500);
+    });
+    const { webSocketFactory } = scriptedSockets([{ open: true }, { open: true }]);
+    const adapter = new WorksSquareDesignWorkspace({
+      apiBaseUrl: 'https://square.example',
+      fetchImpl: fetchMock,
+      webSocketFactory,
+    });
+
+    const first = await adapter.openWorkspaceEvents({
+      workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
+    });
+    await adapter.closeEventSessions();
+    await adapter.bootstrap();
+    const second = await adapter.openWorkspaceEvents({
+      workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
+    });
+
+    expect(fetchMock.mock.calls.filter(([url]) => (
+      String(url).endsWith('/conversations/conversation-one')
+    ))).toHaveLength(2);
+    expect(fetchMock.mock.calls.some(([, init]) => init?.method === 'DELETE')).toBe(false);
+    first.close();
+    second.close();
+  });
+
+  it('reports an unavailable persistent Session instead of creating a client-owned Session', async () => {
+    const fetchMock = vi.fn<typeof fetch>().mockResolvedValueOnce(jsonResponse({
+      ...serverConversation,
+      agent_session_id: null,
+    }));
+    const adapter = new WorksSquareDesignWorkspace({
+      apiBaseUrl: 'https://square.example',
+      fetchImpl: fetchMock,
+    });
+
+    await expect(adapter.submitMessage({
+      workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
+      clientTurnId: 'turn-unavailable',
+      expectedTurnRevision: 1,
+      message: 'hello',
+    })).rejects.toMatchObject({
+      status: 503,
+      code: 'DESIGN_CONVERSATION_SESSION_UNAVAILABLE',
+    });
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it('retries a turn once with the refreshed persistent Session when the old Session is stale', async () => {
+    const fetchMock = vi.fn<typeof fetch>()
+      .mockResolvedValueOnce(jsonResponse({ ...serverConversation, agent_session_id: 'session-old' }))
+      .mockResolvedValueOnce(jsonResponse({
+        code: 'agent_session_not_found',
+        message: 'stale',
+      }, 404))
+      .mockResolvedValueOnce(jsonResponse({ ...serverConversation, agent_session_id: 'session-new' }))
+      .mockResolvedValueOnce(jsonResponse({
+        run_id: 'run-new',
+        status: 'queued',
+        error: null,
+      }, 202))
+      .mockResolvedValueOnce(jsonResponse({
+        run_id: 'run-new',
+        status: 'succeeded',
+        error: null,
+      }))
+      .mockResolvedValueOnce(jsonResponse({ ...serverConversation, agent_session_id: 'session-new' }));
+    const adapter = new WorksSquareDesignWorkspace({
+      apiBaseUrl: 'https://square.example',
+      fetchImpl: fetchMock,
+    });
+
+    await expect(adapter.submitMessage({
+      workspaceId: 'workspace-one',
+      conversationId: 'conversation-one',
+      clientTurnId: 'turn-retry',
+      expectedTurnRevision: 1,
+      message: 'retry',
+    })).resolves.toMatchObject({ conversationId: 'conversation-one' });
+
+    expect(fetchMock.mock.calls.map(([url]) => String(url))).toEqual([
+      'https://square.example/api/design/workspaces/workspace-one/conversations/conversation-one',
+      'https://square.example/api/agents/sessions/session-old/commands',
+      'https://square.example/api/design/workspaces/workspace-one/conversations/conversation-one',
+      'https://square.example/api/agents/sessions/session-new/commands',
+      'https://square.example/api/agents/sessions/session-new/runs/run-new',
+      'https://square.example/api/design/workspaces/workspace-one/conversations/conversation-one',
     ]);
   });
-
-  it('rotates the persisted Session key even when a close result is uncertain', async () => {
-    const rotate = vi.fn().mockResolvedValue('design-stream-next');
-    const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-one', status: 'active' }, 201))
-      .mockResolvedValueOnce(jsonResponse({
-        stream_url: '/api/agents/sessions/session-one/ws?ticket=ticket-one',
-      }))
-      .mockResolvedValueOnce(jsonResponse({
-        detail: { code: 'service_unavailable', message: 'offline' },
-      }, 503));
-    const { webSocketFactory } = scriptedSockets([{ closeCode: 1000 }]);
-    const adapter = new WorksSquareDesignWorkspace({
-      apiBaseUrl: 'https://square.example',
-      fetchImpl: fetchMock,
-      webSocketFactory,
-      eventSessionClientIdStore: {
-        getOrCreate: vi.fn().mockResolvedValue('design-stream-current'),
-        rotate,
-      },
-    });
-
-    const stream = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
-    for await (const _event of stream.events) {
-      // Empty stream.
-    }
-
-    await expect(adapter.closeEventSessions()).rejects.toThrow(
-      'Failed to close 1 AI design Agent Session(s)',
-    );
-    expect(rotate).toHaveBeenCalledWith('workspace-one');
-  });
-
-  it('uses the captured terminal token and tolerates remote close failure after rotating', async () => {
-    const rotate = vi.fn().mockResolvedValue('design-stream-next');
-    const fetchMock = vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-one', status: 'active' }, 201))
-      .mockResolvedValueOnce(jsonResponse({
-        stream_url: '/api/agents/sessions/session-one/ws?ticket=ticket-one',
-      }))
-      .mockResolvedValueOnce(jsonResponse({
-        detail: { code: 'token_expired', message: 'expired' },
-      }, 401));
-    const { webSocketFactory } = scriptedSockets([{ closeCode: 1000 }]);
-    const adapter = new WorksSquareDesignWorkspace({
-      apiBaseUrl: 'https://square.example',
-      fetchImpl: fetchMock,
-      webSocketFactory,
-      eventSessionClientIdStore: {
-        getOrCreate: vi.fn().mockResolvedValue('design-stream-current'),
-        rotate,
-      },
-    });
-
-    const stream = await adapter.openWorkspaceEvents({ workspaceId: 'workspace-one' });
-    for await (const _event of stream.events) {
-      // Empty stream.
-    }
-
-    await expect(adapter.closeEventSessions({
-      accessToken: 'captured-terminal-access-token',
-      tolerateRemoteFailure: true,
-    })).resolves.toBeUndefined();
-    const deleteCall = fetchMock.mock.calls.find(([, init]) => init?.method === 'DELETE');
-    expect(deleteCall?.[1]?.headers).toMatchObject({
-      Authorization: 'Bearer captured-terminal-access-token',
-    });
-    expect(rotate).toHaveBeenCalledWith('workspace-one');
-  });
-
-  it('reuses a stable Session idempotency key after an unclean application restart', async () => {
-    const createFetch = () => vi.fn<typeof fetch>()
-      .mockResolvedValueOnce(jsonResponse({ session_id: 'session-stable', status: 'active' }, 201))
-      .mockResolvedValueOnce(jsonResponse({
-        stream_url: '/api/agents/sessions/session-stable/ws?ticket=ticket-stable',
-      }));
-    const firstFetch = createFetch();
-    const secondFetch = createFetch();
-    const firstSockets = scriptedSockets([{ closeCode: 1000 }]);
-    const restartedSockets = scriptedSockets([{ closeCode: 1000 }]);
-    const first = new WorksSquareDesignWorkspace({
-      apiBaseUrl: 'https://square.example',
-      fetchImpl: firstFetch,
-      clientInstanceId: 'installation-one',
-      webSocketFactory: firstSockets.webSocketFactory,
-    });
-    const restarted = new WorksSquareDesignWorkspace({
-      apiBaseUrl: 'https://square.example',
-      fetchImpl: secondFetch,
-      clientInstanceId: 'installation-one',
-      webSocketFactory: restartedSockets.webSocketFactory,
-    });
-
-    const firstStream = await first.openWorkspaceEvents({ workspaceId: 'workspace-one' });
-    for await (const _event of firstStream.events) {
-      // Empty stream.
-    }
-    const restartedStream = await restarted.openWorkspaceEvents({
-      workspaceId: 'workspace-one',
-    });
-    for await (const _event of restartedStream.events) {
-      // Empty stream.
-    }
-
-    const firstBody = JSON.parse(String(firstFetch.mock.calls[0][1]?.body));
-    const restartedBody = JSON.parse(String(secondFetch.mock.calls[0][1]?.body));
-    expect(firstBody.client_session_id).toBe(restartedBody.client_session_id);
-    expect(firstBody.client_session_id).toMatch(/^design-stream-[a-f0-9]{64}$/);
-  });
 });