feat:暂存修改+还未测试

- 小于最小宽度就自动关闭面板并且提供提示

.gitignore

@@ -3,3 +3,14 @@ dist
 node_modules
 .vscode-test/
 *.vsix
+
+# waveform_trace 打包产物（exe 太大，通过 Release 发布）
+tools/waveform_trace/bin/
+tools/waveform_trace/src/build/
+tools/waveform_trace/src/dist/
+tools/waveform_trace/src/*.spec
+
+# Python 缓存
+__pycache__/
+*.pyc
+*.pyo

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/IC-Coder-Plugin.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/codeStyles/Project.xml

@@ -0,0 +1,16 @@
+<component name="ProjectCodeStyleConfiguration">
+  <code_scheme name="Project" version="173">
+    <JSCodeStyleSettings version="0">
+      <option name="FORCE_SEMICOLON_STYLE" value="true" />
+    </JSCodeStyleSettings>
+    <JavaCodeStyleSettings>
+      <option name="ENABLE_JAVADOC_FORMATTING" value="false" />
+    </JavaCodeStyleSettings>
+    <codeStyleSettings language="JavaScript">
+      <option name="IF_BRACE_FORCE" value="3" />
+      <option name="DOWHILE_BRACE_FORCE" value="3" />
+      <option name="WHILE_BRACE_FORCE" value="3" />
+      <option name="FOR_BRACE_FORCE" value="3" />
+    </codeStyleSettings>
+  </code_scheme>
+</component>

.idea/codeStyles/codeStyleConfig.xml

@@ -0,0 +1,5 @@
+<component name="ProjectCodeStyleConfiguration">
+  <state>
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+  </state>
+</component>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="Eslint" enabled="true" level="WARNING" enabled_by_default="true" />
+  </profile>
+</component>

.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_25" default="true" project-jdk-name="openjdk-25" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/IC-Coder-Plugin.iml" filepath="$PROJECT_DIR$/.idea/IC-Coder-Plugin.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

.vscode/settings.json

@@ -9,5 +9,7 @@
 		"dist": true // set this to false to include "dist" folder in search results
 	},
 	// Turn off tsc task auto detection since we have the necessary tasks as npm scripts
-	"typescript.tsc.autoDetect": "off"
+	"typescript.tsc.autoDetect": "off",
+	// IC Coder 后端服务地址
+	"icCoder.backendUrl": "http://192.168.1.108:2233"
 }

.vscodeignore

@@ -0,0 +1,29 @@
+# 排除开发文件
+.vscode/**
+.git/**
+.gitignore
+node_modules/**
+src/**
+**/*.ts
+**/*.map
+
+# 排除测试文件
+test/**
+**/*.test.js
+
+# 排除文档
+*.md
+!README.md
+
+# 排除 waveform_trace Python 源码（只保留 exe）
+tools/waveform_trace/src/**
+tools/waveform_trace/build/**
+tools/waveform_trace/dist/**
+tools/waveform_trace/build.bat
+tools/waveform_trace/build.sh
+
+# 排除打包临时文件
+**/__pycache__/**
+**/*.pyc
+**/*.pyo
+**/*.spec

CLAUDE.md

@@ -0,0 +1,90 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+IC Coder Plugin 是一个 VS Code 扩展，为 Verilog/FPGA 开发提供智能辅助功能，包括代码生成、文件操作、iverilog 仿真和 VCD 波形查看。
+
+## Build Commands
+
+```bash
+# 安装依赖
+pnpm install
+
+# 编译 (开发模式)
+pnpm run compile
+
+# 监听模式编译
+pnpm run watch
+
+# 生产环境打包
+pnpm run package
+
+# 代码检查
+pnpm run lint
+
+# 运行测试
+pnpm run test
+
+# 编译测试文件
+pnpm run compile-tests
+```
+
+## Development
+
+- 按 F5 在 VS Code 中启动调试模式
+- 使用 webpack 打包，入口文件为 `src/extension.ts`
+- 输出目录为 `dist/`
+
+## Architecture
+
+```
+src/
+├── extension.ts          # 插件入口，注册命令和视图
+├── panels/
+│   ├── ICHelperPanel.ts  # 主聊天面板 (WebviewPanel)
+│   └── VCDViewerPanel.ts # VCD 波形查看器面板
+├── views/
+│   ├── ICViewProvider.ts # 侧边栏视图提供者
+│   └── webviewContent.ts # Webview HTML 内容 (大文件，使用搜索)
+├── utils/
+│   ├── messageHandler.ts # 消息处理核心逻辑 (大文件，使用搜索)
+│   ├── iverilogRunner.ts # iverilog 编译和仿真执行
+│   ├── chatHistoryManager.ts # 会话历史管理
+│   ├── createFiles.ts    # 文件创建工具
+│   └── readFiles.ts      # 文件读取工具
+├── types/
+│   └── chatHistory.ts    # 消息类型定义 (LangChain4j 格式)
+└── test/                 # 测试文件
+```
+
+### Key Components
+
+**消息流程**: Webview -> `onDidReceiveMessage` -> `messageHandler.ts` -> 后端处理 -> `panel.webview.postMessage` -> Webview
+
+**消息类型** (`src/types/chatHistory.ts`):
+- `MessageType.SYSTEM` / `USER` / `AI` / `TOOL_EXECUTION_RESULT`
+- 兼容 LangChain4j 格式
+
+**iverilog 集成** (`tools/iverilog/`):
+- 内置 Windows x64 版本的 iverilog/vvp
+- 通过 `IVERILOG_ROOT` 环境变量配置库路径
+- 支持命令: "生成 VCD"、"运行仿真"、"生成波形"
+
+## VS Code Extension Points
+
+- 命令: `ic-coder.openPanel`, `ic-coder.openChat`, `ic-coder.openVCDViewer`
+- 侧边栏视图: `ic-coder.mainView`
+- 激活事件: `onLanguage:verilog`, `onLanguage:vhdl`, `onStartupFinished`
+
+## Dependencies
+
+- `vcdrom`, `vcd-stream`, `waveql` - VCD 波形处理
+- `@wavedrom/doppler`, `onml` - 波形渲染
+- `iconv-lite` - 编码转换
+
+## Notes
+
+- `webviewContent.ts` 和 `messageHandler.ts` 文件较大，建议使用搜索而非完整读取
+- 当前仅支持 Windows 平台的 iverilog，其他平台需用户自行安装

LICENSE

@@ -0,0 +1,12 @@
+Copyright (c) 2025 IC Coder Team. All rights reserved.
+
+本软件及其相关文档文件（以下简称"软件"）的版权归 IC Coder 所有。
+
+未经版权所有者事先书面许可，不得以任何形式或方式（电子、机械、复印、录制或其他方式）
+复制、分发、传播、展示、修改或创建本软件的衍生作品。
+
+本软件按"原样"提供，不提供任何明示或暗示的保证，包括但不限于适销性、特定用途适用性
+和非侵权性的保证。在任何情况下，作者或版权持有人均不对任何索赔、损害或其他责任负责，
+无论是在合同诉讼、侵权行为还是其他方面。
+
+如需商业使用或获取许可，请联系：[pyjtkj@pyjtkj.com]

PUBLISH.md

@@ -0,0 +1,356 @@
+# IC Coder 插件发布流程文档
+
+本文档详细说明如何将 IC Coder 插件发布到 VS Code 插件市场进行测试和正式发布。
+
+## 目录
+
+- [前置准备](#前置准备)
+- [账号配置](#账号配置)
+- [插件信息完善](#插件信息完善)
+- [打包与发布](#打包与发布)
+- [版本更新](#版本更新)
+- [常见问题](#常见问题)
+
+---
+
+## 前置准备
+
+### 环境要求
+
+- Node.js 和 pnpm 已安装
+- VS Code 1.80.0 或更高版本
+- 已安装 `@vscode/vsce` 工具（项目已包含）
+
+### 检查清单
+
+在发布前，请确保以下文件和配置已准备就绪：
+
+- [x] `package.json` - 插件配置文件
+- [x] `README.md` - 插件说明文档
+- [x] `dist/` - 编译后的代码
+- [x] `media/` - 图标和资源文件
+- [ ] `CHANGELOG.md` - 版本更新日志（建议添加）
+- [x] `LICENSE` - 开源许可证（建议添加）
+
+---
+
+## 账号配置
+
+### 1. 创建 Azure DevOps 账号
+
+1. 访问 [Azure DevOps](https://dev.azure.com)
+2. 使用 Microsoft 账号注册或登录
+3. 创建一个组织（如果还没有）
+
+### 2. 生成 Personal Access Token (PAT)
+
+这是发布插件的关键凭证，请妥善保管。
+
+**步骤：**
+
+1. 登录 Azure DevOps
+2. 点击右上角用户图标 → **User settings** → **Personal access tokens**
+3. 点击 **New Token** 按钮
+4. 配置 Token 信息：
+   - **Name**: `vscode-publisher`（或其他易识别的名称）
+   - **Organization**: 选择 **All accessible organizations**
+   - **Expiration**: 建议选择较长期限（如 90 天或自定义）
+   - **Scopes**: 选择 **Custom defined**
+     - 展开 **Marketplace**
+     - 勾选 **Manage**（包含发布和管理权限）
+5. 点击 **Create** 生成 Token
+6. **重要**: 立即复制并保存 Token，页面关闭后将无法再次查看
+
+**Token 示例格式：**
+
+```
+CO03l8nmFBBTNPDg7lN9a9fYwDdgsRIDVDwTrx6Esggi6HnzmrMTJQQJ99BLACAAAAAAAAAAAAAGAZDOVVyT
+```
+
+### 3. 创建发布者账号
+
+发布者账号是你在 VS Code 市场的身份标识。
+
+**步骤：**
+
+1. 访问 [VS Code Marketplace 管理页面](https://marketplace.visualstudio.com/manage)
+2. 使用 Azure DevOps 账号登录
+3. 点击 **Create publisher** 按钮
+4. 填写发布者信息：
+   - **ID**: `ICCoder`（必须与 package.json 中的 `publisher` 字段一致）
+   - **Name**: `IC Coder`（显示名称，可自定义）
+   - **Email**: 你的联系邮箱
+5. 点击 **Create** 完成创建
+
+**注意事项：**
+- Publisher ID 一旦创建无法修改
+- Publisher ID 必须全局唯一
+- 建议使用有意义且专业的 ID
+
+---
+
+## 插件信息完善
+
+### 1. 完善 package.json
+
+建议在 `package.json` 中添加以下字段以提升插件质量：
+
+```json
+{
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/your-org/ic-coder.git"
+  },
+  "homepage": "https://github.com/your-org/ic-coder#readme",
+  "bugs": {
+    "url": "https://github.com/your-org/ic-coder/issues"
+  },
+  "license": "MIT"
+}
+```
+
+### 2. 创建 CHANGELOG.md
+
+版本更新日志帮助用户了解每个版本的变化。
+
+**示例内容：**
+
+```markdown
+# 更新日志
+
+## [0.0.2] - 2025-12-29
+
+### 新增
+- 添加发送和暂停按钮功能
+- 添加一键优化按钮组件
+- 添加 Plan 开关组件
+- 添加模式选择器组件
+- 添加上下文压缩功能
+
+### 改进
+- 优化用户界面交互体验
+
+## [0.0.1] - 2025-12-XX
+
+### 新增
+- 初始版本发布
+- Verilog 代码智能生成
+- 集成 iverilog 仿真工具
+- VCD 波形文件查看器
+```
+
+### 3. 创建 LICENSE 文件
+
+如果使用 MIT 许可证，创建 `LICENSE` 文件：
+
+```
+MIT License
+
+Copyright (c) 2025 IC Coder Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction...
+```
+
+### 4. 优化 README.md
+
+确保 README 包含：
+- 清晰的功能介绍
+- 使用截图或 GIF 演示
+- 详细的使用说明
+- 系统要求
+- 常见问题解答
+
+---
+
+## 打包与发布
+
+### 方式一：命令行发布（推荐）
+
+这是最便捷的发布方式，适合频繁更新。
+
+**步骤：**
+
+1. **登录发布者账号**
+
+```bash
+pnpm vsce login ic-coder-team
+```
+
+系统会提示输入 Personal Access Token，粘贴之前创建的 PAT。
+
+2. **打包插件**
+
+```bash
+# 执行生产环境构建
+pnpm run package
+
+# 打包成 .vsix 文件
+pnpm vsce package
+```
+
+这会生成 `ic-coder-plugin-0.0.2.vsix` 文件。
+
+3. **发布到市场**
+
+```bash
+pnpm vsce publish
+```
+
+发布成功后会显示插件的市场链接。
+
+**一键发布（跳过打包步骤）：**
+
+```bash
+# 直接发布当前版本
+pnpm vsce publish
+```
+
+### 方式二：手动上传
+
+适合首次发布或网络环境受限的情况。
+
+**步骤：**
+
+1. 本地打包插件：
+```bash
+pnpm run package
+pnpm vsce package[pnpm vsce package --no-dependencies]
+```
+
+2. 访问 [发布者管理页面](https://marketplace.visualstudio.com/manage/publishers/ic-coder-team)
+
+3. 点击 **New extension** → **Visual Studio Code**
+
+4. 上传 `ic-coder-plugin-0.0.2.vsix` 文件
+
+5. 填写插件信息（如果需要）并提交
+
+6. 等待审核通过
+
+---
+
+## 版本更新
+
+### 自动更新版本号
+
+使用 `vsce publish` 命令可以自动更新版本号并发布：
+
+```bash
+# 补丁版本更新（0.0.2 → 0.0.3）
+pnpm vsce publish patch
+
+# 次版本更新（0.0.2 → 0.1.0）
+pnpm vsce publish minor
+
+# 主版本更新（0.0.2 → 1.0.0）
+pnpm vsce publish major
+```
+
+### 手动指定版本
+
+```bash
+# 发布指定版本
+pnpm vsce publish 0.0.3
+```
+
+### 更新流程建议
+
+1. 修改代码并测试
+2. 更新 `CHANGELOG.md` 记录变更
+3. 提交代码到 Git
+4. 执行发布命令
+5. 验证市场上的插件是否正常
+
+---
+
+## 常见问题
+
+### 1. 发布失败：Authentication failed
+
+**原因：** PAT Token 无效或过期
+
+**解决方案：**
+- 重新生成 PAT Token
+- 重新登录：`pnpm vsce login ic-coder-team`
+
+### 2. 发布失败：Publisher not found
+
+**原因：** Publisher ID 不存在或不匹配
+
+**解决方案：**
+- 检查 `package.json` 中的 `publisher` 字段
+- 确认已在市场创建对应的 Publisher
+
+### 3. 打包失败：Missing files
+
+**原因：** 必需文件缺失
+
+**解决方案：**
+- 确保 `dist/` 目录存在且包含编译后的代码
+- 运行 `pnpm run package` 重新构建
+
+### 4. 插件审核被拒
+
+**常见原因：**
+- 插件名称或描述违反市场规则
+- 图标不符合要求（建议 128x128 PNG）
+- README 内容不完整
+
+**解决方案：**
+- 查看审核反馈邮件
+- 修改相关内容后重新发布
+
+### 5. 如何撤回已发布的版本？
+
+```bash
+# 取消发布指定版本
+pnpm vsce unpublish ic-coder-team.ic-coder-plugin@0.0.2
+
+# 取消发布整个插件（慎用）
+pnpm vsce unpublish ic-coder-team.ic-coder-plugin
+```
+
+### 6. 如何本地测试 .vsix 文件？
+
+```bash
+# 在 VS Code 中安装本地 .vsix 文件
+code --install-extension ic-coder-plugin-0.0.2.vsix
+```
+
+或者在 VS Code 中：
+1. 打开扩展面板
+2. 点击 `...` 菜单
+3. 选择 **Install from VSIX...**
+4. 选择 `.vsix` 文件
+
+---
+
+## 发布检查清单
+
+在正式发布前，请确认以下事项：
+
+- [ ] 代码已充分测试，无明显 Bug
+- [ ] `package.json` 版本号已更新
+- [ ] `CHANGELOG.md` 已记录本次更新内容
+- [ ] README.md 内容完整且准确
+- [ ] 图标和资源文件正常显示
+- [ ] 已在本地安装测试 .vsix 文件
+- [ ] 已创建 Azure DevOps PAT Token
+- [ ] 已创建 VS Code Marketplace Publisher
+- [ ] 已执行 `pnpm run package` 构建生产版本
+
+---
+
+## 参考资源
+
+- [VS Code 插件发布官方文档](https://code.visualstudio.com/api/working-with-extensions/publishing-extension)
+- [vsce 工具文档](https://github.com/microsoft/vscode-vsce)
+- [Azure DevOps 文档](https://docs.microsoft.com/en-us/azure/devops/)
+- [VS Code 插件市场](https://marketplace.visualstudio.com/)
+
+---
+
+**文档维护：** IC Coder Team
+**最后更新：** 2025-12-29

docs/authentication-implementation.md

@@ -0,0 +1,573 @@
+# IC Coder 认证系统实现文档
+
+## 概述
+
+本文档详细说明了 IC Coder 插件如何集成 VSCode Authentication API，实现用户登录功能，并在 VSCode 左下角账户区域显示登录状态。
+
+## 架构设计
+
+### 核心组件
+
+1. **ICCoderAuthenticationProvider** - 认证提供者
+2. **VSCode Authentication API** - VSCode 官方认证接口
+3. **本地 HTTP 服务器** - 处理登录回调
+4. **ICViewProvider** - 侧边栏视图（根据登录状态显示不同按钮）
+
+### 工作流程
+
+```
+用户点击登录
+    ↓
+调用 vscode.authentication.getSession()
+    ↓
+ICCoderAuthenticationProvider.createSession()
+    ↓
+启动本地 HTTP 服务器（动态端口）
+    ↓
+打开浏览器访问登录页面
+    ↓
+用户在网站完成登录
+    ↓
+网站重定向到 http://localhost:{port}/callback?token=xxx
+    ↓
+本地服务器接收 token
+    ↓
+创建 AuthenticationSession
+    ↓
+VSCode 左下角显示账户信息
+```
+
+## 详细实现
+
+### 1. Authentication Provider 实现
+
+文件：`src/services/icCoderAuthProvider.ts`
+
+#### 1.1 类定义
+
+```typescript
+export class ICCoderAuthenticationProvider
+  implements vscode.AuthenticationProvider
+{
+  private _onDidChangeSessions =
+    new vscode.EventEmitter<vscode.AuthenticationProviderAuthenticationSessionsChangeEvent>();
+  public readonly onDidChangeSessions = this._onDidChangeSessions.event;
+
+  private _sessions: vscode.AuthenticationSession[] = [];
+}
+```
+
+**关键点：**
+
+- 实现 `vscode.AuthenticationProvider` 接口
+- 使用 `EventEmitter` 通知会话变化
+- 在内存中维护会话列表
+
+#### 1.2 核心方法
+
+##### getSessions() - 获取会话列表
+
+```typescript
+async getSessions(scopes?: readonly string[]): Promise<readonly vscode.AuthenticationSession[]> {
+  return this._sessions;
+}
+```
+
+##### createSession() - 创建会话（登录）
+
+```typescript
+async createSession(scopes: readonly string[]): Promise<vscode.AuthenticationSession> {
+  const token = await this.login();
+
+  const session: vscode.AuthenticationSession = {
+    id: this.generateSessionId(),
+    accessToken: token,
+    account: {
+      id: "iccoder-user",
+      label: "IC Coder 用户",
+    },
+    scopes: [...scopes],
+  };
+
+  this._sessions.push(session);
+  await this.saveSessions();
+
+  this._onDidChangeSessions.fire({
+    added: [session],
+    removed: [],
+    changed: [],
+  });
+
+  return session;
+}
+```
+
+**关键点：**
+
+- 调用 `login()` 方法获取 token
+- 创建 `AuthenticationSession` 对象
+- 保存到 `globalState`
+- 触发 `onDidChangeSessions` 事件通知 VSCode
+
+##### removeSession() - 删除会话（登出）
+
+```typescript
+async removeSession(sessionId: string): Promise<void> {
+  const sessionIndex = this._sessions.findIndex((s) => s.id === sessionId);
+  if (sessionIndex > -1) {
+    const session = this._sessions[sessionIndex];
+    this._sessions.splice(sessionIndex, 1);
+    await this.saveSessions();
+
+    this._onDidChangeSessions.fire({
+      added: [],
+      removed: [session],
+      changed: [],
+    });
+  }
+}
+```
+
+### 2. 本地 HTTP 服务器实现
+
+#### 2.1 动态端口分配
+
+```typescript
+server.listen(0, () => {
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 3000;
+  resolve({ server, port });
+});
+```
+
+**关键点：**
+
+- 使用端口 `0` 让系统自动分配可用端口
+- 避免端口冲突问题
+- 支持多个用户同时使用
+
+#### 2.2 回调处理
+
+```typescript
+if (url.pathname === "/callback") {
+  const token = url.searchParams.get("token");
+
+  if (token) {
+    // 返回成功页面
+    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+    res.end(this.getSuccessPage(iconBase64));
+
+    // 关闭服务器
+    server.close();
+
+    // 返回 token
+    if ((server as any)._loginResolve) {
+      (server as any)._loginResolve(token);
+    }
+  }
+}
+```
+
+### 3. package.json 配置
+
+#### 3.1 注册 Authentication Provider
+
+```json
+{
+  "contributes": {
+    "authentication": [
+      {
+        "id": "iccoder",
+        "label": "IC Coder"
+      }
+    ]
+  }
+}
+```
+
+**关键点：**
+
+- `id` 必须与代码中使用的 ID 一致
+- `label` 会显示在 VSCode 账户菜单中
+
+#### 3.2 注册命令
+
+```json
+{
+  "contributes": {
+    "commands": [
+      {
+        "command": "ic-coder.login",
+        "title": "IC Coder: 登录账户",
+        "category": "IC Coder"
+      },
+      {
+        "command": "ic-coder.logout",
+        "title": "IC Coder: 退出登录",
+        "category": "IC Coder"
+      }
+    ]
+  }
+}
+```
+
+### 4. extension.ts 注册
+
+#### 4.1 注册 Authentication Provider
+
+```typescript
+export function activate(context: vscode.ExtensionContext) {
+  // 注册 Authentication Provider
+  const authProvider = new ICCoderAuthenticationProvider(context);
+  context.subscriptions.push(
+    vscode.authentication.registerAuthenticationProvider(
+      "iccoder",
+      "IC Coder",
+      authProvider
+    )
+  );
+}
+```
+
+#### 4.2 登录命令
+
+```typescript
+const loginCommand = vscode.commands.registerCommand(
+  "ic-coder.login",
+  async () => {
+    try {
+      await vscode.authentication.getSession("iccoder", [], {
+        createIfNone: true,
+      });
+    } catch (error) {
+      vscode.window.showErrorMessage(`登录失败: ${error}`);
+    }
+  }
+);
+```
+
+**关键点：**
+
+- `createIfNone: true` 会在没有会话时自动调用 `createSession()`
+- VSCode 会自动处理 UI 交互
+
+#### 4.3 登出命令
+
+```typescript
+const logoutCommand = vscode.commands.registerCommand(
+  "ic-coder.logout",
+  async () => {
+    try {
+      const session = await vscode.authentication.getSession("iccoder", [], {
+        createIfNone: false,
+      });
+      if (session) {
+        await vscode.authentication.getSession("iccoder", [], {
+          clearSessionPreference: true,
+          forceNewSession: true,
+        });
+        vscode.window.showInformationMessage("已退出登录");
+      }
+    } catch (error) {
+      vscode.window.showInformationMessage("当前未登录");
+    }
+  }
+);
+```
+
+### 5. ICViewProvider 集成
+
+#### 5.1 检查登录状态
+
+```typescript
+private async checkLoginStatus(): Promise<boolean> {
+  try {
+    const session = await vscode.authentication.getSession("iccoder", [], { createIfNone: false });
+    return !!session;
+  } catch (error) {
+    return false;
+  }
+}
+```
+
+#### 5.2 根据登录状态显示不同按钮
+
+```typescript
+resolveWebviewView(webviewView: vscode.WebviewView) {
+  this.checkLoginStatus().then((isLoggedIn) => {
+    webviewView.webview.html = this.getWebviewContent(
+      webviewView.webview,
+      isLoggedIn
+    );
+  });
+}
+```
+
+```typescript
+${isLoggedIn
+  ? '<button class="btn" onclick="openChat()">开始创作</button>'
+  : '<button class="btn" onclick="login()">登录账户</button>'
+}
+```
+
+### 6. 网站前端配置
+
+#### 6.1 检测插件登录请求
+
+```javascript
+// 在登录页面检测 redirect_uri 参数
+const urlParams = new URLSearchParams(window.location.search);
+const redirectUri = urlParams.get("redirect_uri");
+
+if (redirectUri) {
+  // 保存回调地址
+  localStorage.setItem("plugin_redirect_uri", redirectUri);
+}
+```
+
+#### 6.2 登录成功后重定向
+
+```javascript
+// 用户登录成功，拿到 token
+const token = response.data.token;
+
+// 检查是否需要重定向回插件
+const redirectUri = localStorage.getItem("plugin_redirect_uri");
+
+if (redirectUri) {
+  // 重定向回插件，带上 token
+  window.location.href = `${redirectUri}?token=${token}`;
+  localStorage.removeItem("plugin_redirect_uri");
+} else {
+  // 正常登录流程
+  router.push("/dashboard");
+}
+```
+
+## 关键技术点
+
+### 1. 动态端口分配
+
+**问题：** 固定端口可能被占用，导致登录失败
+
+**解决方案：** 使用端口 `0` 让系统自动分配可用端口
+
+```typescript
+server.listen(0, () => {
+  const address = server.address();
+  const port = typeof address === "object" && address ? address.port : 3000;
+});
+```
+
+### 2. Promise 异步等待
+
+**问题：** 需要等待浏览器登录完成后才能继续
+
+**解决方案：** 使用 Promise 包装回调逻辑
+
+```typescript
+return new Promise((resolve, reject) => {
+  (server as any)._loginResolve = resolve;
+  (server as any)._loginReject = reject;
+});
+```
+
+### 3. 会话持久化
+
+**问题：** 重启 VSCode 后需要重新登录
+
+**解决方案：** 使用 `globalState` 保存会话
+
+```typescript
+await this.context.globalState.update("icCoderSessions", this._sessions);
+```
+
+### 4. 事件通知机制
+
+**问题：** VSCode 需要知道会话状态变化
+
+**解决方案：** 使用 `EventEmitter` 触发事件
+
+```typescript
+this._onDidChangeSessions.fire({
+  added: [session],
+  removed: [],
+  changed: [],
+});
+```
+
+## 用户体验
+
+### 登录流程
+
+1. 用户点击侧边栏"登录账户"按钮
+2. 浏览器自动打开登录页面
+3. 用户在网站完成登录
+4. 浏览器自动跳转到成功页面
+5. VSCode 左下角显示"IC Coder 用户"
+6. 侧边栏按钮变为"开始创作"
+
+### 登出流程
+
+1. 点击 VSCode 左下角账户图标
+2. 选择"IC Coder"账户
+3. 点击"退出"按钮
+4. 或使用命令 `IC Coder: 退出登录`
+
+## 常见问题
+
+### Q1: 为什么不直接使用 globalState 存储 token？
+
+**A:** 使用 VSCode Authentication API 的优势：
+
+- ✅ 统一的用户体验（左下角账户区域）
+- ✅ VSCode 自动管理会话生命周期
+- ✅ 支持多账户切换
+- ✅ 更好的安全性（VSCode 负责加密存储）
+
+### Q2: 如何处理 token 过期？
+
+**A:** 可以在 API 请求失败时：
+
+1. 检测 401 错误
+2. 调用 `removeSession()` 清除过期会话
+3. 提示用户重新登录
+
+### Q3: 如何支持多个账户？
+
+**A:** 修改 `account` 对象：
+
+```typescript
+account: {
+  id: userInfo.id,
+  label: userInfo.username,
+}
+```
+
+### Q4: 登录页面如何获取用户信息？
+
+**A:** 可以在登录成功后，通过 API 获取用户信息：
+
+```typescript
+const userInfo = await fetch("https://api.iccoder.com/user/info", {
+  headers: { Authorization: `Bearer ${token}` },
+});
+
+const session: vscode.AuthenticationSession = {
+  account: {
+    id: userInfo.id,
+    label: userInfo.username,
+  },
+  // ...
+};
+```
+
+## 安全考虑
+
+### 1. Token 存储
+
+- ✅ 使用 VSCode `globalState` 加密存储
+- ✅ 不在代码中硬编码敏感信息
+- ✅ Token 仅在内存和加密存储中传递
+
+### 2. 本地服务器
+
+- ✅ 仅监听 `localhost`，不暴露到外网
+- ✅ 使用动态端口，避免固定端口被劫持
+- ✅ 接收到 token 后立即关闭服务器
+- ✅ 设置 5 分钟超时，防止服务器长期运行
+
+### 3. HTTPS 考虑
+
+**当前实现：** 使用 HTTP 本地回调
+
+**生产环境建议：**
+
+- 网站使用 HTTPS
+- 本地回调使用 HTTP（localhost 不受浏览器限制）
+- 或使用 `vscode://` 协议（需要网站支持）
+
+## 测试指南
+
+### 1. 本地测试
+
+```bash
+# 启动调试模式
+按 F5
+
+# 测试登录
+1. 打开侧边栏
+2. 点击"登录账户"
+3. 在浏览器完成登录
+4. 检查左下角是否显示账户
+
+# 测试登出
+1. 点击左下角账户
+2. 选择"IC Coder"
+3. 点击"退出"
+```
+
+### 2. 调试技巧
+
+```typescript
+// 在 ICCoderAuthenticationProvider 中添加日志
+console.log("🔐 创建会话:", session);
+console.log("🔑 Token:", token);
+
+// 在 ICViewProvider 中添加日志
+console.log("🔍 登录状态:", isLoggedIn);
+```
+
+### 3. 常见错误排查
+
+| 错误                            | 原因            | 解决方案                           |
+| ------------------------------- | --------------- | ---------------------------------- |
+| `getSessions is not a function` | VSCode 版本过低 | 升级到 1.63.0+                     |
+| 端口被占用                      | 固定端口冲突    | 使用动态端口（已实现）             |
+| 登录后未显示账户                | 未触发事件      | 检查 `_onDidChangeSessions.fire()` |
+| 重启后需要重新登录              | 未保存会话      | 检查 `saveSessions()` 调用         |
+
+## 文件结构
+
+```
+ic-coder/
+├── src/
+│   ├── services/
+│   │   └── icCoderAuthProvider.ts    # Authentication Provider 实现
+│   ├── views/
+│   │   └── ICViewProvider.ts         # 侧边栏视图（集成登录状态）
+│   └── extension.ts                  # 注册 Provider 和命令
+├── package.json                      # 配置 authentication 和 commands
+└── docs/
+    └── authentication-implementation.md  # 本文档
+```
+
+## 参考资料
+
+- [VSCode Authentication API](https://code.visualstudio.com/api/references/vscode-api#authentication)
+- [Authentication Provider Sample](https://github.com/microsoft/vscode-extension-samples/tree/main/authentication-sample)
+- [VSCode Extension Guidelines](https://code.visualstudio.com/api/references/extension-guidelines)
+
+## 总结
+
+本实现通过以下步骤完成了 VSCode Authentication API 的集成：
+
+1. ✅ 创建 `ICCoderAuthenticationProvider` 类实现认证逻辑
+2. ✅ 在 `package.json` 中注册 authentication provider
+3. ✅ 在 `extension.ts` 中注册 provider 和命令
+4. ✅ 实现本地 HTTP 服务器处理登录回调
+5. ✅ 使用动态端口避免冲突
+6. ✅ 集成到侧边栏视图，根据登录状态显示不同按钮
+7. ✅ 配置网站前端支持插件登录重定向
+
+**最终效果：**
+
+- 用户登录后，VSCode 左下角显示"IC Coder 用户"
+- 侧边栏根据登录状态显示"登录账户"或"开始创作"按钮
+- 支持通过账户菜单或命令进行登录/登出操作
+
+---
+
+**文档版本：** 1.0  
+**最后更新：** 2025-12-29  
+**作者：** Roe-xin

docs/会话存储技术文档.md

@@ -0,0 +1,751 @@
+# IC Coder 会话存储技术文档
+
+## 1. 概述
+
+IC Coder 的会话存储系统负责持久化保存用户与 AI 的对话历史，支持多项目、多任务的会话管理。系统采用文件系统存储方案，将会话数据按项目和任务组织，便于管理和检索。
+
+### 1.1 核心特性
+
+- **多项目支持**：不同项目的会话数据独立存储
+- **任务级管理**：每个会话作为独立任务进行管理
+- **分页加载**：支持历史会话的分页查询，提升性能
+- **实时更新**：会话数据实时保存，防止数据丢失
+- **统计信息**：记录 Token 使用量、对话轮次等统计数据
+
+### 1.2 技术栈
+
+- **存储方式**：文件系统（JSON/JSONL 格式）
+- **存储位置**：`~/.iccoder/projects/{项目路径编码}/{taskId}/`
+- **数据格式**：
+  - `meta.json`：任务元数据
+  - `conversation.json`：完整对话历史
+  - `conversation_meta.jsonl`：对话轮次元数据（JSONL 格式）
+
+---
+
+## 2. 架构设计
+
+### 2.1 目录结构
+
+```
+~/.iccoder/
+└── projects/
+    └── {项目路径编码}/
+        └── {taskId}/
+            ├── meta.json              # 任务元数据
+            ├── conversation.json      # 对话历史
+            └── conversation_meta.jsonl # 对话元数据
+```
+
+**项目路径编码规则**：
+- 移除冒号 `:`
+- 将斜杠 `/` 和反斜杠 `\` 替换为 `--`
+- 示例：`C:\Users\admin\Documents\Project` → `C--Users--admin--Documents--Project`
+
+**任务 ID 格式**：
+- 格式：`task_{date}_{sequence}`
+- 示例：`task_20231226_a3f9k2`
+- `date`：8 位日期（YYYYMMDD）
+- `sequence`：6 位随机字符串
+
+### 2.2 核心类：ChatHistoryManager
+
+`ChatHistoryManager` 是会话存储的核心管理类，采用单例模式设计。
+
+**主要职责**：
+1. 管理会话存储目录
+2. 创建和切换任务
+3. 保存和加载对话历史
+4. 记录统计信息
+5. 提供会话历史查询接口
+
+**关键属性**：
+```typescript
+private static instance: ChatHistoryManager;
+private baseDir: string;                    // ~/.iccoder
+private currentTaskId: string | null;       // 当前任务 ID
+private currentProjectPath: string | null;  // 当前项目路径
+```
+
+---
+
+## 3. 数据模型
+
+### 3.1 TaskMeta（任务元数据）
+
+存储在 `meta.json` 文件中，记录任务的基本信息和统计数据。
+
+```typescript
+interface TaskMeta {
+  taskId: string;           // 任务 ID
+  taskName: string;         // 任务名称
+  projectPath: string;      // 项目路径
+  createdAt: string;        // 创建时间（ISO 8601）
+  updatedAt: string;        // 更新时间（ISO 8601）
+  stats: {
+    credits: number;        // 消耗的积分
+    totalTokens: number;    // 总 Token 数
+    inputTokens: number;    // 输入 Token 数
+    outputTokens: number;   // 输出 Token 数
+  };
+}
+```
+
+**示例**：
+```json
+{
+  "taskId": "task_20231226_a3f9k2",
+  "taskName": "实现计数器功能",
+  "projectPath": "C:\\Users\\admin\\Documents\\Project",
+  "createdAt": "2023-12-26T10:30:00.000Z",
+  "updatedAt": "2023-12-26T11:45:00.000Z",
+  "stats": {
+    "credits": 0,
+    "totalTokens": 15420,
+    "inputTokens": 8200,
+    "outputTokens": 7220
+  }
+}
+```
+
+### 3.2 ChatMessage（对话消息）
+
+存储在 `conversation.json` 文件中，记录完整的对话历史。
+
+**消息类型枚举**：
+```typescript
+enum MessageType {
+  USER = "USER",                           // 用户消息
+  AI = "AI",                               // AI 消息
+  SYSTEM = "SYSTEM",                       // 系统消息
+  TOOL_EXECUTION_RESULT = "TOOL_EXECUTION_RESULT"  // 工具执行结果
+}
+```
+
+**用户消息**：
+```typescript
+interface UserMessage {
+  type: MessageType.USER;
+  contents: Array<{
+    type: "TEXT";
+    text: string;
+  }>;
+}
+```
+
+**AI 消息**：
+```typescript
+interface AiMessage {
+  type: MessageType.AI;
+  text: string;
+  toolExecutionRequests?: Array<{
+    id: string;
+    toolName: string;
+    parameters: any;
+  }>;
+}
+```
+
+**系统消息**：
+```typescript
+interface SystemMessage {
+  type: MessageType.SYSTEM;
+  text: string;
+}
+```
+
+**工具执行结果消息**：
+```typescript
+interface ToolExecutionResultMessage {
+  type: MessageType.TOOL_EXECUTION_RESULT;
+  id: string;
+  toolName: string;
+  text: string;
+}
+```
+
+### 3.3 ConversationMeta（对话轮次元数据）
+
+存储在 `conversation_meta.jsonl` 文件中，每行一条记录（JSONL 格式）。
+
+```typescript
+interface ConversationMeta {
+  turnId: number;           // 对话轮次 ID
+  timestamp: string;        // 时间戳（ISO 8601）
+  usage?: {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+  };
+  model?: string;           // 使用的模型
+  duration?: number;        // 耗时（毫秒）
+}
+```
+
+**示例**：
+```jsonl
+{"turnId":1,"timestamp":"2023-12-26T10:30:15.000Z","usage":{"inputTokens":120,"outputTokens":350,"totalTokens":470},"model":"gpt-4","duration":2500}
+{"turnId":2,"timestamp":"2023-12-26T10:32:30.000Z","usage":{"inputTokens":200,"outputTokens":450,"totalTokens":650},"model":"gpt-4","duration":3200}
+```
+
+---
+
+## 4. 核心功能实现
+
+### 4.1 任务创建
+
+**方法**：`createTask(projectPath: string, taskName: string): Promise<TaskMeta>`
+
+**流程**：
+1. 生成唯一的任务 ID
+2. 创建任务元数据对象
+3. 创建任务目录
+4. 保存 `meta.json`
+5. 初始化空的 `conversation.json`
+6. 设置为当前任务
+
+**代码位置**：`chatHistoryManager.ts:114-146`
+
+```typescript
+public async createTask(projectPath: string, taskName: string): Promise<TaskMeta> {
+  const taskId = this.generateTaskId();
+  const now = new Date().toISOString();
+
+  const meta: TaskMeta = {
+    taskId,
+    taskName,
+    projectPath,
+    createdAt: now,
+    updatedAt: now,
+    stats: {
+      credits: 0,
+      totalTokens: 0,
+      inputTokens: 0,
+      outputTokens: 0
+    }
+  };
+
+  this.currentTaskId = taskId;
+  this.currentProjectPath = projectPath;
+
+  // 创建任务目录
+  const taskDir = this.getTaskDir(projectPath, taskId);
+  await this.ensureTaskDir(taskDir);
+
+  // 保存 meta.json
+  await this.saveTaskMeta(meta);
+
+  // 初始化空的 conversation.json
+  await this.saveConversation([]);
+
+  return meta;
+}
+```
+
+### 4.2 消息保存
+
+系统提供了四种消息保存方法：
+
+#### 4.2.1 添加用户消息
+
+**方法**：`addUserMessage(text: string): Promise<void>`
+
+**代码位置**：`chatHistoryManager.ts:285-299`
+
+```typescript
+public async addUserMessage(text: string): Promise<void> {
+  await this.ensureCurrentTask();
+  const messages = await this.loadConversation();
+
+  const userMessage: UserMessage = {
+    type: MessageType.USER,
+    contents: [{ type: "TEXT", text }]
+  };
+
+  messages.push(userMessage);
+  await this.saveConversation(messages);
+
+  // 更新任务元数据
+  await this.updateTaskTimestamp();
+}
+```
+
+#### 4.2.2 添加 AI 消息
+
+**方法**：`addAiMessage(text: string, toolRequests?: any[]): Promise<void>`
+
+**代码位置**：`chatHistoryManager.ts:304-319`
+
+#### 4.2.3 添加系统消息
+
+**方法**：`addSystemMessage(text: string): Promise<void>`
+
+**代码位置**：`chatHistoryManager.ts:324-335`
+
+#### 4.2.4 添加工具执行结果
+
+**方法**：`addToolExecutionResult(id: string, toolName: string, result: string): Promise<void>`
+
+**代码位置**：`chatHistoryManager.ts:340-353`
+
+### 4.3 对话元数据记录
+
+**方法**：`recordTurnMeta(turnId, usage?, model?, duration?): Promise<void>`
+
+**功能**：记录每轮对话的元数据，包括 Token 使用量、模型信息、耗时等。
+
+**代码位置**：`chatHistoryManager.ts:358-378`
+
+```typescript
+public async recordTurnMeta(
+  turnId: number,
+  usage?: { inputTokens?: number; outputTokens?: number; totalTokens?: number },
+  model?: string,
+  duration?: number
+): Promise<void> {
+  const meta: ConversationMeta = {
+    turnId,
+    timestamp: new Date().toISOString(),
+    usage,
+    model,
+    duration
+  };
+
+  await this.appendConversationMeta(meta);
+
+  // 更新任务统计
+  if (usage) {
+    await this.updateTaskStats(usage);
+  }
+}
+```
+
+### 4.4 会话历史查询
+
+**方法**：`getConversationHistoryList(projectPath, offset, limit): Promise<{items, total, hasMore}>`
+
+**功能**：分页查询项目的会话历史列表。
+
+**参数**：
+- `projectPath`：项目路径
+- `offset`：偏移量（从第几条开始，默认 0）
+- `limit`：每页数量（默认 10）
+
+**返回值**：
+```typescript
+{
+  items: Array<{
+    id: string;        // 任务 ID
+    title: string;     // 会话标题（第一句用户消息）
+    timestamp: string; // 创建时间
+  }>;
+  total: number;       // 总数
+  hasMore: boolean;    // 是否还有更多
+}
+```
+
+**代码位置**：`chatHistoryManager.ts:525-590`
+
+**实现逻辑**：
+1. 获取项目的所有任务列表（按更新时间倒序）
+2. 根据 offset 和 limit 进行分页
+3. 读取每个任务的 `conversation.json`
+4. 提取第一条用户消息作为标题（截取前 50 个字符）
+5. 返回分页结果
+
+---
+
+## 5. 前端集成
+
+### 5.1 会话历史栏组件
+
+**文件**：`conversationHistoryBar.ts`
+
+**组件结构**：
+- 下拉按钮：显示 "Past Conversations"
+- 下拉菜单：显示会话历史列表
+- 新建按钮：创建新会话
+
+**关键功能**：
+
+#### 5.1.1 加载会话历史
+
+```javascript
+function loadMoreHistory() {
+  if (isLoadingHistory || (currentOffset > 0 && !hasMoreHistory)) {
+    return;
+  }
+
+  // 检查是否已达到最大数量（100 条）
+  if (currentOffset >= MAX_HISTORY_ITEMS) {
+    return;
+  }
+
+  isLoadingHistory = true;
+  vscode.postMessage({
+    command: 'loadConversationHistory',
+    offset: currentOffset,
+    limit: HISTORY_PAGE_SIZE
+  });
+}
+```
+
+#### 5.1.2 渲染会话列表
+
+```javascript
+function renderConversationHistory(data) {
+  isLoadingHistory = false;
+
+  // 追加新数据
+  conversationHistory = conversationHistory.concat(data.items);
+  totalHistory = data.total;
+  hasMoreHistory = data.hasMore;
+  currentOffset += data.items.length;
+
+  // 渲染所有历史记录
+  historyList.innerHTML = conversationHistory.map(item => `
+    <div class="history-item" onclick="selectConversation('${item.id}')">
+      <div class="history-item-title">${item.title || '未命名会话'}</div>
+      <div class="history-item-time">${formatTime(item.timestamp)}</div>
+    </div>
+  `).join('');
+
+  // 如果还有更多数据，添加"加载更多"提示
+  if (hasMoreHistory && currentOffset < MAX_HISTORY_ITEMS) {
+    historyList.innerHTML += `
+      <div class="history-load-more">
+        <span>滚动加载更多...</span>
+      </div>
+    `;
+  }
+}
+```
+
+#### 5.1.3 滚动加载
+
+```javascript
+historyDropdownMenu.addEventListener('scroll', () => {
+  const menu = historyDropdownMenu;
+  const scrollTop = menu.scrollTop;
+  const scrollHeight = menu.scrollHeight;
+  const clientHeight = menu.clientHeight;
+
+  // 当滚动到距离底部 50px 时，加载更多
+  if (scrollHeight - scrollTop - clientHeight < 50) {
+    loadMoreHistory();
+  }
+});
+```
+
+#### 5.1.4 时间格式化
+
+```javascript
+function formatTime(timestamp) {
+  const date = new Date(timestamp);
+  const now = new Date();
+  const diff = now - date;
+
+  if (diff < 60000) return '刚刚';
+  if (diff < 3600000) return Math.floor(diff / 60000) + '分钟前';
+  if (diff < 86400000) return Math.floor(diff / 3600000) + '小时前';
+  if (diff < 604800000) return Math.floor(diff / 86400000) + '天前';
+
+  // 超过7天显示具体日期
+  return date.toLocaleDateString('zh-CN', {
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit'
+  });
+}
+```
+
+### 5.2 后端消息处理
+
+**文件**：`ICHelperPanel.ts`
+
+**消息处理流程**：
+
+```typescript
+case "loadConversationHistory":
+  // 加载会话历史（支持分页）
+  loadConversationHistory(panel, message.offset || 0, message.limit || 10);
+  break;
+
+case "selectConversation":
+  // 选择会话（暂未实现）
+  break;
+
+case "createNewConversation":
+  // 创建新会话 - 在当前编辑器组中打开新标签页
+  showICHelperPanel(context, panel.viewColumn);
+  break;
+```
+
+**加载会话历史实现**：
+
+```typescript
+async function loadConversationHistory(
+  panel: vscode.WebviewPanel,
+  offset: number = 0,
+  limit: number = 10
+) {
+  try {
+    const historyManager = ChatHistoryManager.getInstance();
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+
+    if (!workspacePath) {
+      // 没有打开的工作区，返回空历史
+      panel.webview.postMessage({
+        command: "conversationHistory",
+        items: [],
+        total: 0,
+        hasMore: false,
+      });
+      return;
+    }
+
+    // 获取会话历史列表（支持分页）
+    const result = await historyManager.getConversationHistoryList(
+      workspacePath,
+      offset,
+      limit
+    );
+
+    // 发送会话历史到前端
+    panel.webview.postMessage({
+      command: "conversationHistory",
+      items: result.items,
+      total: result.total,
+      hasMore: result.hasMore,
+    });
+  } catch (error) {
+    console.error("加载会话历史失败:", error);
+    // 发生错误时返回空历史
+    panel.webview.postMessage({
+      command: "conversationHistory",
+      items: [],
+      total: 0,
+      hasMore: false,
+    });
+  }
+}
+```
+
+---
+
+## 6. 使用示例
+
+### 6.1 创建新任务并保存对话
+
+```typescript
+const historyManager = ChatHistoryManager.getInstance();
+
+// 创建新任务
+const task = await historyManager.createTask(
+  'C:\\Users\\admin\\Documents\\Project',
+  '实现计数器功能'
+);
+
+// 添加用户消息
+await historyManager.addUserMessage('请帮我生成一个4位计数器');
+
+// 添加 AI 消息
+await historyManager.addAiMessage(
+  '好的，我来帮你生成一个4位计数器...',
+  [{ id: '1', toolName: 'generateCode', parameters: {} }]
+);
+
+// 添加工具执行结果
+await historyManager.addToolExecutionResult(
+  '1',
+  'generateCode',
+  '代码生成成功'
+);
+
+// 记录对话元数据
+await historyManager.recordTurnMeta(
+  1,
+  { inputTokens: 120, outputTokens: 350, totalTokens: 470 },
+  'gpt-4',
+  2500
+);
+```
+
+### 6.2 查询会话历史
+
+```typescript
+const historyManager = ChatHistoryManager.getInstance();
+
+// 获取第一页（前10条）
+const page1 = await historyManager.getConversationHistoryList(
+  'C:\\Users\\admin\\Documents\\Project',
+  0,
+  10
+);
+
+console.log('总数:', page1.total);
+console.log('是否还有更多:', page1.hasMore);
+console.log('会话列表:', page1.items);
+
+// 获取第二页（第11-20条）
+const page2 = await historyManager.getConversationHistoryList(
+  'C:\\Users\\admin\\Documents\\Project',
+  10,
+  10
+);
+```
+
+### 6.3 切换任务
+
+```typescript
+const historyManager = ChatHistoryManager.getInstance();
+
+// 切换到指定任务
+const success = await historyManager.switchTask(
+  'C:\\Users\\admin\\Documents\\Project',
+  'task_20231226_a3f9k2'
+);
+
+if (success) {
+  // 获取当前任务会话
+  const session = await historyManager.getCurrentTaskSession();
+  console.log('任务元数据:', session.meta);
+  console.log('对话历史:', session.messages);
+  console.log('对话元数据:', session.conversationMeta);
+}
+```
+
+---
+
+## 7. 性能优化
+
+### 7.1 分页加载
+
+- 前端默认每页加载 10 条记录
+- 最多显示 100 条历史记录
+- 滚动到底部时自动加载下一页
+
+### 7.2 懒加载
+
+- 只在打开下拉菜单时才加载会话历史
+- 避免不必要的文件读取操作
+
+### 7.3 缓存机制
+
+- 前端缓存已加载的会话列表
+- 避免重复请求相同数据
+
+### 7.4 文件格式优化
+
+- 使用 JSONL 格式存储对话元数据，支持追加写入
+- 避免频繁读写整个文件
+
+---
+
+## 8. 错误处理
+
+### 8.1 目录不存在
+
+系统会自动创建不存在的目录：
+
+```typescript
+private async ensureTaskDir(taskDir: string): Promise<void> {
+  try {
+    const uri = vscode.Uri.file(taskDir);
+    try {
+      await vscode.workspace.fs.stat(uri);
+    } catch {
+      // 目录不存在，创建它
+      await vscode.workspace.fs.createDirectory(uri);
+      console.log(`创建任务目录: ${taskDir}`);
+    }
+  } catch (error) {
+    console.error("创建任务目录失败:", error);
+    throw error;
+  }
+}
+```
+
+### 8.2 文件读取失败
+
+读取失败时返回默认值：
+
+```typescript
+private async loadConversation(): Promise<ChatMessage[]> {
+  try {
+    const uri = vscode.Uri.file(conversationPath);
+    const content = await vscode.workspace.fs.readFile(uri);
+    const data = Buffer.from(content).toString('utf-8');
+    return JSON.parse(data);
+  } catch (error) {
+    // 文件不存在或读取失败，返回空数组
+    return [];
+  }
+}
+```
+
+### 8.3 无工作区处理
+
+没有打开工作区时，自动创建默认任务：
+
+```typescript
+private async ensureCurrentTask(): Promise<void> {
+  if (!this.currentTaskId || !this.currentProjectPath) {
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+    if (workspacePath) {
+      await this.createTask(workspacePath, "默认任务");
+    } else {
+      throw new Error("没有打开的工作区，无法创建任务");
+    }
+  }
+}
+```
+
+---
+
+## 9. 未来扩展
+
+### 9.1 会话切换功能
+
+目前 `selectConversation` 功能暂未实现，未来可以支持：
+- 点击历史会话，加载该会话的完整对话历史
+- 在新标签页中打开历史会话
+- 继续历史会话的对话
+
+### 9.2 会话搜索
+
+- 支持按关键词搜索会话
+- 支持按时间范围筛选
+- 支持按 Token 使用量排序
+
+### 9.3 会话导出
+
+- 导出为 Markdown 格式
+- 导出为 JSON 格式
+- 导出为 PDF 格式
+
+### 9.4 会话统计
+
+- 显示总对话轮次
+- 显示总 Token 使用量
+- 显示平均响应时间
+
+### 9.5 云端同步
+
+- 支持将会话数据同步到云端
+- 支持多设备访问
+- 支持团队协作
+
+---
+
+## 10. 总结
+
+IC Coder 的会话存储系统采用文件系统存储方案，具有以下优势：
+
+1. **简单可靠**：无需额外的数据库依赖
+2. **易于备份**：直接复制文件即可备份
+3. **跨平台**：支持 Windows、macOS、Linux
+4. **可扩展**：易于添加新的数据字段
+5. **高性能**：分页加载，避免一次性加载大量数据
+
+系统已经实现了核心的会话管理功能，包括任务创建、消息保存、历史查询等，为用户提供了完整的会话历史管理体验。

media/surfer/index.html

@@ -0,0 +1,200 @@
+<!DOCTYPE html>
+<html>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+<!-- Disable zooming: -->
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+
+<head>
+    <!-- change this to your project name -->
+    <title>Surfer</title>
+
+    <!-- config for our rust wasm binary. go to https://trunkrs.dev/assets/#rust for more customization -->
+        <script type="module">
+        import init from '/surfer.js';
+        await init({module_or_path: '/surfer_bg.wasm'});
+        import {WebHandle, inject_message, id_of_name, draw_text_arrow} from '/surfer.js';
+        window.inject_message = inject_message;
+        window.id_of_name = id_of_name;
+        window.draw_text_arrow = draw_text_arrow;
+        /*SURFER_SETUP_HOOKS*/
+    </script>
+    
+    <!-- this is the base url relative to which other urls will be constructed. trunk will insert this from the public-url option -->
+    <base href="/" />
+
+
+    <script>
+        function on_surfer_error(msg) {
+            console.log("Setting error message")
+            document.getElementById("error_message").innerHTML = msg
+            document.getElementById("error_container").style.display = "block"
+        }
+        window.on_surfer_error = on_surfer_error;
+    </script>
+
+
+    
+    
+    
+
+    <link rel="manifest" href="manifest.json">
+    <meta name="theme-color" media="(prefers-color-scheme: light)" content="white">
+    <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#404040">
+
+    <style>
+        html {
+            /* Remove touch delay: */
+            touch-action: manipulation;
+        }
+
+        body {
+            /* Light mode background color for what is not covered by the egui canvas,
+            or where the egui canvas is translucent. */
+            background: #909090;
+        }
+
+        @media (prefers-color-scheme: dark) {
+            body {
+                /* Dark mode background color for what is not covered by the egui canvas,
+                or where the egui canvas is translucent. */
+                background: #404040;
+            }
+        }
+
+        /* Allow canvas to fill entire web page: */
+        html,
+        body {
+            overflow: hidden;
+            margin: 0 !important;
+            padding: 0 !important;
+            height: 100%;
+            width: 100%;
+        }
+
+        /* Make canvas fill entire document: */
+        canvas {
+            margin-right: auto;
+            margin-left: auto;
+            display: block;
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+        }
+
+        .centered {
+            margin-right: auto;
+            margin-left: auto;
+            display: block;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            color: #f0f0f0;
+            font-size: 24px;
+            font-family: Ubuntu-Light, Helvetica, sans-serif;
+            text-align: center;
+        }
+
+        /* ---------------------------------------------- */
+        /* Loading animation from https://loading.io/css/ */
+        .lds-dual-ring {
+            display: inline-block;
+            width: 24px;
+            height: 24px;
+        }
+
+        .lds-dual-ring:after {
+            content: " ";
+            display: block;
+            width: 24px;
+            height: 24px;
+            margin: 0px;
+            border-radius: 50%;
+            border: 3px solid #fff;
+            border-color: #fff transparent #fff transparent;
+            animation: lds-dual-ring 1.2s linear infinite;
+        }
+
+        @keyframes lds-dual-ring {
+            0% {
+                transform: rotate(0deg);
+            }
+
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+
+        #error_container {
+            padding: 1em;
+            border-radius: 0.5em;
+            margin: 0px auto;
+            max-width: 980px;
+            color: #ffffff;
+            background-color: black;
+            position: relative;
+            height: 90%;
+            overflow: scroll;
+        }
+
+        #error_container a {
+            color: #ff9999;
+        }
+
+        #error_message {
+            overflow: scroll;
+            white-space: break-spaces;
+        }
+    </style>
+<link rel="modulepreload" href="/surfer.js" crossorigin="anonymous" integrity="sha384-s5jcnzgSMjwjfa1Jq5kr3vQVXGQ7D+ZdMsCBdbbcmKefqvRKw652YAYaaHZJQob6"><link rel="preload" href="/surfer_bg.wasm" crossorigin="anonymous" integrity="sha384-YzYZZQJDXiKIAVpyBMziailnMHJ/sxzBq0VNMP854yLbTd2lneCR5ZgcvB4cYMFc" as="fetch" type="application/wasm"></head>
+
+<body>
+    <!-- The WASM code will resize the canvas dynamically -->
+    <!-- the id is hardcoded in main.rs . so, make sure both match. -->
+    <canvas id="the_canvas_id"></canvas>
+
+    <div id="error_container" style="display: none;">
+        <h1>Sorry, Surfer crashed 🔥</h1>
+        <p>
+            Something caused Surfer to crash. Please report the error on
+            <a href="https://gitlab.com/surfer-project/surfer/-/issues/new">
+                gitlab
+            </a>
+        </p>
+        <p>
+            Any report is appreciated, but it is extra helpful if you can attach the waveform that caused
+            the crash and/or the steps to reproduce the crash.
+        </p>
+        <h3>
+            Backtrace:
+        </h3>
+        <div class="error_container">
+            <!-- This is filled in by javascript -->
+            <code id="error_message"></code>
+        </div>
+    </div>
+
+    <!-- Register the message listener system -->
+    <script src="integration.js"></script>
+    <script>
+        register_message_listener()
+    </script>
+
+    <!--Register Service Worker. this will cache the wasm / js scripts for offline use (for PWA functionality). -->
+    <!-- Force refresh (Ctrl + F5) to load the latest files instead of cached files  -->
+    <script>
+        // We disable caching during development so that we always view the latest version.
+        if ('serviceWorker' in navigator && window.location.hash !== "#dev") {
+            window.addEventListener('load', function () {
+                navigator.serviceWorker.register('sw.js');
+            });
+        }
+    </script>
+</body>
+
+</html>
+
+<!-- Powered by egui: https://github.com/emilk/egui/ -->

media/surfer/integration.js

@@ -0,0 +1,65 @@
+// Web apps which integrate Surfer as an iframe can give commands to surfer via
+// the .postMessage [1] function on the iframe.
+//
+//  For example, to tell Surfer to load waveforms from a URL, use
+// `.postMessage({command: "LoadUrl", url: "https://app.surfer-project.org/picorv32.vcd"})`
+//
+//  For more complex functionality, one can also inject any `Message` defined
+// in `surfer::Message` in surfer/main.rs. However, the API of these messages
+// is not stable and may change at any time. If you add functionality via
+// these, make sure to test the new functionality when changing Surfer version.
+//
+// [1] https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
+
+function register_message_listener() {
+  window.addEventListener("message", (event) => {
+    // JSON decode the message
+    const decoded = event.data
+
+    switch (decoded.command) {
+      // Load a waveform from a URL. The format is inferred from the data.
+      // Example: `{command: "LoadUrl", url: "https://app.surfer-project.org/picorv32.vcd"}`
+
+      case 'LoadUrl': {
+        const msg = {
+          LoadWaveformFileFromUrl: [
+            decoded.url,
+            "Clear"
+          ]
+        }
+        inject_message(JSON.stringify(msg))
+        break;
+      }
+
+      case 'ToggleMenu': {
+        const msg = "ToggleMenu"
+        inject_message(JSON.stringify(msg))
+        break;
+      }
+
+      // Load waveform data directly from string content
+      case 'LoadData': {
+        const msg = {
+          LoadFromData: [
+            decoded.content,
+            decoded.fileName || "waveform.vcd",
+            "Clear"
+          ]
+        }
+        inject_message(JSON.stringify(msg))
+        break;
+      }
+
+      // Inject any other message supported by Surfer in the surfer::Message enum.
+      // NOTE: The API of these is unstable.
+      case 'InjectMessage': {
+        inject_message(decoded.message);
+        break
+      }
+
+      default:
+        console.log(`Unknown message.command ${decoded.command}`)
+        break;
+    }
+  });
+}

media/surfer/manifest.json

@@ -0,0 +1,10 @@
+{
+  "background_color": "white",
+  "display": "standalone",
+  "id": "/index.html",
+  "lang": "en-US",
+  "name": "Surfer",
+  "short_name": "surfer",
+  "start_url": "./index.html",
+  "theme_color": "white"
+}

media/surfer/surfer/index.html

@@ -0,0 +1,200 @@
+<!DOCTYPE html>
+<html>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+
+<!-- Disable zooming: -->
+<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+
+<head>
+    <!-- change this to your project name -->
+    <title>Surfer</title>
+
+    <!-- config for our rust wasm binary. go to https://trunkrs.dev/assets/#rust for more customization -->
+        <script type="module">
+        import init from '/surfer.js';
+        await init({module_or_path: '/surfer_bg.wasm'});
+        import {WebHandle, inject_message, id_of_name, draw_text_arrow} from '/surfer.js';
+        window.inject_message = inject_message;
+        window.id_of_name = id_of_name;
+        window.draw_text_arrow = draw_text_arrow;
+        /*SURFER_SETUP_HOOKS*/
+    </script>
+    
+    <!-- this is the base url relative to which other urls will be constructed. trunk will insert this from the public-url option -->
+    <base href="/" />
+
+
+    <script>
+        function on_surfer_error(msg) {
+            console.log("Setting error message")
+            document.getElementById("error_message").innerHTML = msg
+            document.getElementById("error_container").style.display = "block"
+        }
+        window.on_surfer_error = on_surfer_error;
+    </script>
+
+
+    
+    
+    
+
+    <link rel="manifest" href="manifest.json">
+    <meta name="theme-color" media="(prefers-color-scheme: light)" content="white">
+    <meta name="theme-color" media="(prefers-color-scheme: dark)" content="#404040">
+
+    <style>
+        html {
+            /* Remove touch delay: */
+            touch-action: manipulation;
+        }
+
+        body {
+            /* Light mode background color for what is not covered by the egui canvas,
+            or where the egui canvas is translucent. */
+            background: #909090;
+        }
+
+        @media (prefers-color-scheme: dark) {
+            body {
+                /* Dark mode background color for what is not covered by the egui canvas,
+                or where the egui canvas is translucent. */
+                background: #404040;
+            }
+        }
+
+        /* Allow canvas to fill entire web page: */
+        html,
+        body {
+            overflow: hidden;
+            margin: 0 !important;
+            padding: 0 !important;
+            height: 100%;
+            width: 100%;
+        }
+
+        /* Make canvas fill entire document: */
+        canvas {
+            margin-right: auto;
+            margin-left: auto;
+            display: block;
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+        }
+
+        .centered {
+            margin-right: auto;
+            margin-left: auto;
+            display: block;
+            position: absolute;
+            top: 50%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            color: #f0f0f0;
+            font-size: 24px;
+            font-family: Ubuntu-Light, Helvetica, sans-serif;
+            text-align: center;
+        }
+
+        /* ---------------------------------------------- */
+        /* Loading animation from https://loading.io/css/ */
+        .lds-dual-ring {
+            display: inline-block;
+            width: 24px;
+            height: 24px;
+        }
+
+        .lds-dual-ring:after {
+            content: " ";
+            display: block;
+            width: 24px;
+            height: 24px;
+            margin: 0px;
+            border-radius: 50%;
+            border: 3px solid #fff;
+            border-color: #fff transparent #fff transparent;
+            animation: lds-dual-ring 1.2s linear infinite;
+        }
+
+        @keyframes lds-dual-ring {
+            0% {
+                transform: rotate(0deg);
+            }
+
+            100% {
+                transform: rotate(360deg);
+            }
+        }
+
+        #error_container {
+            padding: 1em;
+            border-radius: 0.5em;
+            margin: 0px auto;
+            max-width: 980px;
+            color: #ffffff;
+            background-color: black;
+            position: relative;
+            height: 90%;
+            overflow: scroll;
+        }
+
+        #error_container a {
+            color: #ff9999;
+        }
+
+        #error_message {
+            overflow: scroll;
+            white-space: break-spaces;
+        }
+    </style>
+<link rel="modulepreload" href="/surfer.js" crossorigin="anonymous" integrity="sha384-s5jcnzgSMjwjfa1Jq5kr3vQVXGQ7D+ZdMsCBdbbcmKefqvRKw652YAYaaHZJQob6"><link rel="preload" href="/surfer_bg.wasm" crossorigin="anonymous" integrity="sha384-YzYZZQJDXiKIAVpyBMziailnMHJ/sxzBq0VNMP854yLbTd2lneCR5ZgcvB4cYMFc" as="fetch" type="application/wasm"></head>
+
+<body>
+    <!-- The WASM code will resize the canvas dynamically -->
+    <!-- the id is hardcoded in main.rs . so, make sure both match. -->
+    <canvas id="the_canvas_id"></canvas>
+
+    <div id="error_container" style="display: none;">
+        <h1>Sorry, Surfer crashed 🔥</h1>
+        <p>
+            Something caused Surfer to crash. Please report the error on
+            <a href="https://gitlab.com/surfer-project/surfer/-/issues/new">
+                gitlab
+            </a>
+        </p>
+        <p>
+            Any report is appreciated, but it is extra helpful if you can attach the waveform that caused
+            the crash and/or the steps to reproduce the crash.
+        </p>
+        <h3>
+            Backtrace:
+        </h3>
+        <div class="error_container">
+            <!-- This is filled in by javascript -->
+            <code id="error_message"></code>
+        </div>
+    </div>
+
+    <!-- Register the message listener system -->
+    <script src="integration.js"></script>
+    <script>
+        register_message_listener()
+    </script>
+
+    <!--Register Service Worker. this will cache the wasm / js scripts for offline use (for PWA functionality). -->
+    <!-- Force refresh (Ctrl + F5) to load the latest files instead of cached files  -->
+    <script>
+        // We disable caching during development so that we always view the latest version.
+        if ('serviceWorker' in navigator && window.location.hash !== "#dev") {
+            window.addEventListener('load', function () {
+                navigator.serviceWorker.register('sw.js');
+            });
+        }
+    </script>
+</body>
+
+</html>
+
+<!-- Powered by egui: https://github.com/emilk/egui/ -->

media/surfer/surfer/integration.js

@@ -0,0 +1,52 @@
+// Web apps which integrate Surfer as an iframe can give commands to surfer via
+// the .postMessage [1] function on the iframe.
+//
+//  For example, to tell Surfer to load waveforms from a URL, use
+// `.postMessage({command: "LoadUrl", url: "https://app.surfer-project.org/picorv32.vcd"})`
+//
+//  For more complex functionality, one can also inject any `Message` defined
+// in `surfer::Message` in surfer/main.rs. However, the API of these messages
+// is not stable and may change at any time. If you add functionality via
+// these, make sure to test the new functionality when changing Surfer version.
+//
+// [1] https://developer.mozilla.org/en-US/docs/Web/API/Window/postMessage
+
+function register_message_listener() {
+  window.addEventListener("message", (event) => {
+    // JSON decode the message
+    const decoded = event.data
+
+    switch (decoded.command) {
+      // Load a waveform from a URL. The format is inferred from the data.
+      // Example: `{command: "LoadUrl", url: "https://app.surfer-project.org/picorv32.vcd"}`
+
+      case 'LoadUrl': {
+        const msg = {
+          LoadWaveformFileFromUrl: [
+            decoded.url,
+            "Clear"
+          ]
+        }
+        inject_message(JSON.stringify(msg))
+        break;
+      }
+
+      case 'ToggleMenu': {
+        const msg = "ToggleMenu"
+        inject_message(JSON.stringify(msg))
+        break;
+      }
+
+      // Inject any other message supported by Surfer in the surfer::Message enum.
+      // NOTE: The API of these is unstable.
+      case 'InjectMessage': {
+        inject_message(decoded.message);
+        break
+      }
+
+      default:
+        console.log(`Unknown message.command ${decoded.command}`)
+        break;
+    }
+  });
+}

media/surfer/surfer/manifest.json

@@ -0,0 +1,10 @@
+{
+  "background_color": "white",
+  "display": "standalone",
+  "id": "/index.html",
+  "lang": "en-US",
+  "name": "Surfer",
+  "short_name": "surfer",
+  "start_url": "./index.html",
+  "theme_color": "white"
+}

media/surfer/surfer/sw.js

@@ -0,0 +1,37 @@
+self.addEventListener("install", function () {
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("fetch", function (event) {
+  if (event.request.cache === "only-if-cached" && event.request.mode !== "same-origin") {
+    return;
+  }
+
+  event.respondWith(
+    fetch(event.request)
+      .then(function (response) {
+        // It seems like we only need to set the headers for index.html
+        // If you want to be on the safe side, comment this out
+        // if (!response.url.includes("index.html")) return response;
+
+        const newHeaders = new Headers(response.headers);
+        newHeaders.set("Cross-Origin-Embedder-Policy", "require-corp");
+        newHeaders.set("Cross-Origin-Opener-Policy", "same-origin");
+
+        const moddedResponse = new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: newHeaders,
+        });
+
+        return moddedResponse;
+      })
+      .catch(function (e) {
+        console.error(e);
+      })
+  );
+});

media/surfer/sw.js

@@ -0,0 +1,37 @@
+self.addEventListener("install", function () {
+  self.skipWaiting();
+});
+
+self.addEventListener("activate", (event) => {
+  event.waitUntil(self.clients.claim());
+});
+
+self.addEventListener("fetch", function (event) {
+  if (event.request.cache === "only-if-cached" && event.request.mode !== "same-origin") {
+    return;
+  }
+
+  event.respondWith(
+    fetch(event.request)
+      .then(function (response) {
+        // It seems like we only need to set the headers for index.html
+        // If you want to be on the safe side, comment this out
+        // if (!response.url.includes("index.html")) return response;
+
+        const newHeaders = new Headers(response.headers);
+        newHeaders.set("Cross-Origin-Embedder-Policy", "require-corp");
+        newHeaders.set("Cross-Origin-Opener-Policy", "same-origin");
+
+        const moddedResponse = new Response(response.body, {
+          status: response.status,
+          statusText: response.statusText,
+          headers: newHeaders,
+        });
+
+        return moddedResponse;
+      })
+      .catch(function (e) {
+        console.error(e);
+      })
+  );
+});

package.json

@@ -1,14 +1,16 @@
 {
-  "name": "ic-coder-plugin",
+  "name": "iccoder",
-  "displayName": "IC Coder plugin",
+  "displayName": "IC Coder",
   "description": "Agentic Verilog Coding Platform for Real-World FPGAs",
   "version": "0.0.2",
+  "publisher": "ICCoder",
   "engines": {
-    "vscode": "^1.107.0"
+    "vscode": "^1.80.0"
   },
-  "icon": "media/图案（方底）.png",
+  "icon": "media/icon.png",
   "categories": [
-    "Other"
+    "Chat",
+    "Programming Languages"
   ],
   "keywords": [
     "IC",
@@ -18,6 +20,7 @@
     "eda",
     "assistant"
   ],
+  "license": "SEE LICENSE IN LICENSE",
   "activationEvents": [
     "onCommand:ic-coder.openPanel",
     "onView:ic-coder-sidebar",
@@ -42,36 +45,6 @@
         "command": "ic-coder.openVCDViewer",
         "title": "打开 VCD 波形查看器",
         "category": "IC Coder"
-      },
-      {
-        "command": "ic-coder.viewHistory",
-        "title": "查看会话历史",
-        "category": "IC Coder"
-      },
-      {
-        "command": "ic-coder.newSession",
-        "title": "新建会话",
-        "category": "IC Coder"
-      },
-      {
-        "command": "ic-coder.exportSession",
-        "title": "导出当前会话",
-        "category": "IC Coder"
-      },
-      {
-        "command": "ic-coder.deleteSession",
-        "title": "删除会话",
-        "category": "IC Coder"
-      },
-      {
-        "command": "ic-coder.clearHistory",
-        "title": "清空会话历史",
-        "category": "IC Coder"
-      },
-      {
-        "command": "ic-coder.searchSession",
-        "title": "搜索会话",
-        "category": "IC Coder"
       }
     ],
     "viewsContainers": {
@@ -79,7 +52,7 @@
         {
           "id": "ic-coder-sidebar",
           "title": "IC Coder",
-          "icon": "media/侧边栏logo.png"
+          "icon": "media/sidebar-icon.png"
         }
       ]
     },
@@ -91,7 +64,25 @@
           "type": "webview"
         }
       ]
-    }
+    },
+    "authentication": [
+      {
+        "id": "iccoder",
+        "label": "IC Coder"
+      }
+    ],
+    "customEditors": [
+      {
+        "viewType": "ic-coder.vcdViewer",
+        "displayName": "VCD 波形查看器",
+        "selector": [
+          {
+            "filenamePattern": "*.vcd"
+          }
+        ],
+        "priority": "default"
+      }
+    ]
   },
   "scripts": {
     "vscode:prepublish": "pnpm run package",
@@ -108,9 +99,10 @@
   "devDependencies": {
     "@types/mocha": "^10.0.10",
     "@types/node": "22.x",
-    "@types/vscode": "^1.107.0",
+    "@types/vscode": "^1.80.0",
     "@vscode/test-cli": "^0.0.12",
     "@vscode/test-electron": "^2.5.2",
+    "@vscode/vsce": "^3.7.1",
     "eslint": "^9.39.1",
     "ts-loader": "^9.5.4",
     "typescript": "^5.9.3",
@@ -121,10 +113,12 @@
   "files": [
     "dist",
     "media",
-    "tools"
+    "tools",
+    "src/assets"
   ],
   "dependencies": {
     "@wavedrom/doppler": "^1.14.0",
+    "eventsource-parser": "^3.0.6",
     "iconv-lite": "^0.7.1",
     "onml": "^2.1.0",
     "style-mod": "^4.1.3",

src/components/codeHighlight.ts

@@ -0,0 +1,237 @@
+/**
+ * 代码高亮组件
+ *
+ * 功能说明:
+ * - 使用 highlight.js 提供专业的代码语法高亮
+ * - 支持多种编程语言（Verilog, JavaScript, Python 等）
+ * - 提供行内代码和代码块的不同样式
+ * - 自动检测语言类型
+ */
+
+/**
+ * 获取 highlight.js 的 CDN 链接
+ */
+export function getHighlightJsLinks(): string {
+  return `
+    <!-- Highlight.js CSS (VS Code Dark+ 主题) -->
+    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/styles/vs2015.min.css">
+    <!-- Highlight.js 核心库 -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/highlight.min.js"></script>
+    <!-- Verilog 语言支持 -->
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/highlight.js/11.9.0/languages/verilog.min.js"></script>
+  `;
+}
+
+/**
+ * 获取代码高亮的样式
+ */
+export function getCodeHighlightStyles(): string {
+  return `
+    /* 代码块基础样式 */
+    .segment-text pre {
+      background: var(--vscode-textCodeBlock-background);
+      border: 1px solid var(--vscode-panel-border);
+      border-radius: 6px;
+      padding: 12px;
+      overflow-x: auto;
+      margin: 12px 0;
+      position: relative;
+      white-space: pre;
+    }
+
+    .segment-text pre code {
+      background: transparent !important;
+      padding: 0;
+      border: none;
+      display: block;
+      line-height: 1.5;
+      white-space: pre;
+      font-family: 'Courier New', Consolas, 'Monaco', monospace;
+      font-size: 0.9em;
+    }
+
+    /* 行内代码样式 */
+    .segment-text code:not(pre code) {
+      background: var(--vscode-textCodeBlock-background);
+      padding: 2px 6px;
+      border-radius: 3px;
+      color: var(--vscode-textPreformat-foreground);
+      border: 1px solid var(--vscode-panel-border);
+      font-family: 'Courier New', Consolas, 'Monaco', monospace;
+      font-size: 0.9em;
+    }
+
+    /* 覆盖 highlight.js 的背景色，使用 VSCode 主题色 */
+    .segment-text pre code.hljs {
+      background: transparent !important;
+      padding: 0 !important;
+    }
+
+    /* 代码块语言标签 */
+    .code-block-wrapper {
+      position: relative;
+      margin: -20px 0;
+    }
+
+    .code-language-label {
+      position: absolute;
+      top: 8px;
+      right: 8px;
+      background: var(--vscode-badge-background);
+      color: var(--vscode-badge-foreground);
+      padding: 2px 8px;
+      border-radius: 3px;
+      font-size: 11px;
+      font-weight: 500;
+      text-transform: uppercase;
+      opacity: 0.8;
+      z-index: 1;
+    }
+
+    /* 代码块复制按钮 */
+    .code-copy-btn {
+      position: absolute;
+      top: 8px;
+      right: 8px;
+      background: var(--vscode-button-secondaryBackground);
+      color: var(--vscode-button-secondaryForeground);
+      border: 1px solid var(--vscode-button-border);
+      border-radius: 4px;
+      padding: 4px 8px;
+      font-size: 11px;
+      cursor: pointer;
+      opacity: 0;
+      transition: opacity 0.2s ease;
+      z-index: 2;
+    }
+
+    .code-block-wrapper:hover .code-copy-btn {
+      opacity: 1;
+    }
+
+    .code-copy-btn:hover {
+      background: var(--vscode-button-secondaryHoverBackground);
+    }
+
+    .code-copy-btn.copied {
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+    }
+
+    /* 代码块滚动条样式 */
+    .segment-text pre::-webkit-scrollbar {
+      height: 8px;
+    }
+
+    .segment-text pre::-webkit-scrollbar-track {
+      background: var(--vscode-scrollbarSlider-background);
+      border-radius: 4px;
+    }
+
+    .segment-text pre::-webkit-scrollbar-thumb {
+      background: var(--vscode-scrollbarSlider-hoverBackground);
+      border-radius: 4px;
+    }
+
+    .segment-text pre::-webkit-scrollbar-thumb:hover {
+      background: var(--vscode-scrollbarSlider-activeBackground);
+    }
+  `;
+}
+
+/**
+ * 获取代码高亮的脚本
+ */
+export function getCodeHighlightScript(): string {
+  return `
+    /**
+     * 使用 highlight.js 进行代码高亮
+     */
+    function highlightCodeBlocks() {
+      // 等待 highlight.js 加载完成
+      if (typeof hljs === 'undefined') {
+        setTimeout(highlightCodeBlocks, 100);
+        return;
+      }
+
+      const codeBlocks = document.querySelectorAll('.segment-text pre code:not(.hljs)');
+      codeBlocks.forEach((block) => {
+        hljs.highlightElement(block);
+      });
+    }
+
+    /**
+     * 为代码块添加复制按钮
+     */
+    function enhanceCodeBlocks() {
+      const codeBlocks = document.querySelectorAll('.segment-text pre code');
+
+      codeBlocks.forEach((codeElement) => {
+        const preElement = codeElement.parentElement;
+        if (!preElement || preElement.classList.contains('enhanced')) {
+          return;
+        }
+
+        // 标记为已增强，避免重复处理
+        preElement.classList.add('enhanced');
+
+        // 应用语法高亮
+        if (typeof hljs !== 'undefined' && !codeElement.classList.contains('hljs')) {
+          hljs.highlightElement(codeElement);
+        }
+
+        // 创建包装器
+        const wrapper = document.createElement('div');
+        wrapper.className = 'code-block-wrapper';
+        preElement.parentNode.insertBefore(wrapper, preElement);
+        wrapper.appendChild(preElement);
+
+        // 添加复制按钮
+        const copyBtn = document.createElement('button');
+        copyBtn.className = 'code-copy-btn';
+        copyBtn.textContent = '复制';
+        copyBtn.onclick = function() {
+          const code = codeElement.textContent;
+          navigator.clipboard.writeText(code).then(() => {
+            copyBtn.textContent = '已复制';
+            copyBtn.classList.add('copied');
+            setTimeout(() => {
+              copyBtn.textContent = '复制';
+              copyBtn.classList.remove('copied');
+            }, 2000);
+          });
+        };
+        wrapper.appendChild(copyBtn);
+      });
+    }
+
+    /**
+     * 监听 DOM 变化，自动增强新添加的代码块
+     */
+    function observeCodeBlocks() {
+      const observer = new MutationObserver((mutations) => {
+        mutations.forEach((mutation) => {
+          if (mutation.addedNodes.length > 0) {
+            enhanceCodeBlocks();
+          }
+        });
+      });
+
+      observer.observe(document.getElementById('messages'), {
+        childList: true,
+        subtree: true
+      });
+    }
+
+    // 初始化代码块增强
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', () => {
+        enhanceCodeBlocks();
+        observeCodeBlocks();
+      });
+    } else {
+      enhanceCodeBlocks();
+      observeCodeBlocks();
+    }
+  `;
+}

src/config/settings.ts

@@ -0,0 +1,94 @@
+/**
+ * 配置管理
+ * 支持 dev（本地开发）和 test（测试服务器）两种环境
+ */
+import * as vscode from "vscode";
+
+/** 环境类型 */
+type Environment = "dev" | "test" | "prod";
+
+/** 当前环境 - 修改这里切换环境 */
+const CURRENT_ENV: Environment = "test";
+
+/** 服务等级类型 */
+export type ServiceTier = "lite" | "syntaxic" | "max" | "auto";
+
+/** 配置项接口 */
+export interface IccoderConfig {
+  /** 后端服务地址 */
+  backendUrl: string;
+  /** 后端服务地址（strangeLoop） */
+  backendUrlStrongeLoop: string;
+  /** 请求超时时间（毫秒） */
+  timeout: number;
+  /** 用户ID（临时使用，后续对接认证） */
+  userId: string;
+  /** 服务等级 */
+  serviceTier: ServiceTier;
+}
+
+/** 环境配置 */
+const ENV_CONFIG: Record<Environment, IccoderConfig> = {
+  /** 本地开发环境 */
+  dev: {
+    backendUrl: "http://localhost:2233",
+    backendUrlStrongeLoop: "http://192.168.1.108:2029",
+    timeout: 300000,
+    userId: "default-user",
+    serviceTier: "max", // 默认使用 max
+  },
+  /** 测试服务器环境 */
+  test: {
+    backendUrl: "http://192.168.1.108:2233",
+    backendUrlStrongeLoop: "http://192.168.1.108:2029",
+    timeout: 60000,
+    userId: "default-user",
+    serviceTier: "max",
+  },
+  /** 生产环境 */
+  prod: {
+    backendUrl: "https://api.iccoder.com",
+    backendUrlStrongeLoop: "http://api.iccoder.com:2029",
+    timeout: 60000,
+    userId: "default-user",
+    serviceTier: "auto",
+  },
+};
+
+/**
+ * 获取当前环境
+ */
+export function getCurrentEnv(): Environment {
+  return CURRENT_ENV;
+}
+
+/**
+ * 获取配置项
+ */
+export function getConfig(): IccoderConfig {
+  return { ...ENV_CONFIG[CURRENT_ENV] };
+}
+
+/**
+ * 获取后端 API 地址
+ */
+export function getApiUrl(path: string): string {
+  const { backendUrl } = getConfig();
+  const baseUrl = backendUrl.endsWith("/")
+    ? backendUrl.slice(0, -1)
+    : backendUrl;
+  const apiPath = path.startsWith("/") ? path : `/${path}`;
+  return `${baseUrl}${apiPath}`;
+}
+
+/**
+ * 获取 StrangeLoop 服务 API 地址（用于用户信息等）
+ */
+export function getStrangeLoopApiUrl(path: string): string {
+  const { backendUrlStrongeLoop } = getConfig();
+  const baseUrl = backendUrlStrongeLoop.endsWith("/")
+    ? backendUrlStrongeLoop.slice(0, -1)
+    : backendUrlStrongeLoop;
+  const apiPath = path.startsWith("/") ? path : `/${path}`;
+  return `${baseUrl}${apiPath}`;
+}

src/constants/toolIcons.ts

@@ -0,0 +1,182 @@
+/**
+ * 工具图标定义
+ * 包含各种工具的 SVG 图标
+ */
+
+/**
+ * 折叠图标 SVG（用于可折叠的工具结果）
+ */
+export const collapseIconSvg = `
+  <span class="tool-collapse-icon">
+    <svg class="icon-collapsed" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M355.05845325 160.07583932c-19.63862503 19.63862503-19.63862503 51.53175211 0 71.17037712L618.05891976 494.24668297c9.74075802 9.74075802 9.74075802 25.76587604 0 35.50663406L355.05845325 792.75378356c-19.63862503 19.63862503-19.63862503 51.53175211 0 71.17037712s51.53175211 19.63862503 71.17037716 0L706.98261396 583.17037714c39.27725009-39.27725009 39.27725009-102.90639522 0-142.18364526L426.22883041 160.07583932c-19.63862503-19.63862503-51.53175211-19.63862503-71.17037716 0z" fill="#8a8a8a"/>
+    </svg>
+    <svg class="icon-expanded" style="display:none;" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M899.70688 272.92672l-382.19776 373.53472-393.45664-384.512a43.52 43.52 0 0 0-60.52352 0 41.14944 41.14944 0 0 0 0 59.14624l423.72096 414.11584a43.35616 43.35616 0 0 0 60.56448 0l412.4672-403.11296a41.20064 41.20064 0 0 0 11.06432-40.41728 42.3424 42.3424 0 0 0-30.2848-29.58336 43.52 43.52 0 0 0-41.35424 10.84416z m0 0" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 文件写入完成图标 SVG
+ */
+export const fileWriteIconSvg = `
+  <span class="tool-file-write-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M866.304 852.096H161.728a31.36 31.36 0 0 1-30.528-30.592 31.36 31.36 0 0 1 30.528-30.528h704.64a31.36 31.36 0 0 1 30.528 30.528c0 16.32-12.224 30.592-30.592 30.592z m-65.152-134.4h-392.96a31.36 31.36 0 0 1-30.592-30.592 31.36 31.36 0 0 1 30.528-30.528h391.04a31.36 31.36 0 0 1 30.528 30.528c0 16.32-12.224 30.592-28.544 30.592z m-596.672-179.2l91.648 93.632-40.704 40.768-91.648-91.648 40.704-42.752zM552.704 188.16l91.648 93.696-42.752 40.704-91.648-91.648 42.752-42.752z" fill="#8a8a8a"/>
+      <path d="M176 733.952a72.96 72.96 0 0 1-50.88-22.4c-14.272-14.272-22.4-36.672-22.4-56.96l8.128-99.84 423.552-425.6a104.576 104.576 0 0 1 75.328-30.528c32.64 0 63.168 14.272 85.568 36.672 24.384 24.384 36.608 56.96 36.608 89.6 0 28.48-12.16 54.976-32.576 73.28l-419.456 427.648-99.84 8.128H176z m-4.096-152.704l-6.08 77.376c0 4.096 2.048 8.128 4.096 8.128h2.048l77.376-6.08 417.344-425.6c8.128-8.128 12.224-18.304 12.224-28.48 0-14.272-6.08-28.48-16.32-38.72-10.24-10.24-22.4-16.32-36.672-16.32-12.16 0-22.4 4.096-30.528 12.224L171.904 581.248z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 语法检查图标 SVG
+ */
+export const syntaxCheckIconSvg = `
+  <span class="tool-syntax-check-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M143.36 241.8688h638.976a33.28 33.28 0 0 0 0-66.56H143.36a33.28 33.28 0 0 0 0 66.56zM143.36 421.2736h423.5264a33.28 33.28 0 0 0 0-66.56H143.36a33.28 33.28 0 0 0 0 66.56zM419.0208 532.8384H143.36a33.28 33.28 0 0 0 0 66.56h275.6608a33.28 33.28 0 0 0 0-66.56zM365.5168 709.5296H129.0752a33.28 33.28 0 0 0 0 66.56h236.4416a33.28 33.28 0 1 0 0-66.56zM918.4256 791.8592l-82.5856-82.432a178.8928 178.8928 0 1 0-47.0528 47.0528l82.5856 82.4832a33.28 33.28 0 1 0 47.0528-47.104z m-342.3232-182.9376a112.128 112.128 0 1 1 112.128 112.0768 112.2816 112.2816 0 0 1-112.128-112.0768z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 已检索代码图标 SVG
+ */
+export const SearchCode = `
+  <span class="tool-search-code-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M916.33 859.76L678.51 621.94A318.92 318.92 0 0 0 768 400c0-176.73-143.27-320-320-320S128 223.27 128 400s143.27 320 320 320a318.48 318.48 0 0 0 167.88-47.55l243.88 243.88a40 40 0 1 0 56.57-56.57zM192 400c0-141.38 114.62-256 256-256s256 114.62 256 256-114.62 256-256 256-256-114.62-256-256z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 发送按钮图标 SVG（向上箭头）
+ */
+export const sendIconSvg = `
+  <svg class="send-icon" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+    <path d="M507.904 882.688c-18.432 0-33.28-14.848-33.28-33.28v-655.36c0-18.432 14.848-33.28 33.28-33.28s33.28 14.848 33.28 33.28v654.848c0 18.432-14.848 33.792-33.28 33.792z" fill="currentColor"></path>
+    <path d="M787.968 502.784c-8.704 0-16.896-3.072-23.552-9.728L507.904 236.544 251.392 493.056c-12.8 12.8-34.304 12.8-47.104 0-12.8-12.8-12.8-34.304 0-47.104l280.064-280.064c6.144-6.144 14.848-9.728 23.552-9.728s17.408 3.584 23.552 9.728l280.064 280.064c12.8 12.8 12.8 34.304 0 47.104-6.656 6.656-15.36 9.728-23.552 9.728z" fill="currentColor"></path>
+  </svg>
+`;
+
+/**
+ * 暂停按钮图标 SVG（圆形边框内的方块）
+ */
+export const stopIconSvg = `
+  <svg class="stop-icon" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+    <path d="M512 936a424.1 424.1 0 0 1-165.05-814.66 424.1 424.1 0 0 1 330.1 781.33A421.38 421.38 0 0 1 512 936z m0-768c-189.68 0-344 154.32-344 344s154.32 344 344 344 344-154.32 344-344-154.32-344-344-344z" fill="currentColor"></path>
+    <path d="M349.75 349.75m57.15 0l210.2 0q57.15 0 57.15 57.15l0 210.2q0 57.15-57.15 57.15l-210.2 0q-57.15 0-57.15-57.15l0-210.2q0-57.15 57.15-57.15Z" fill="currentColor"></path>
+  </svg>
+`;
+
+/**
+ * 探索智能体图标 SVG
+ */
+export const agentIconSvg = `
+<svg t="1767101071638" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="7779" width="16" height="16" style="display: inline-block; vertical-align: middle;"><path d="M173.474909 410.414545c-20.293818 0-33.838545-13.498182-33.838545-33.792v-135.377454C139.636364 187.066182 187.019636 139.636364 241.198545 139.636364h135.447273c20.270545 0 33.815273 13.591273 33.815273 33.885091s-13.591273 33.838545-33.885091 33.838545h-135.447273c-20.317091 0-33.815273 13.591273-33.815272 33.885091v135.377454c0.046545 20.293818-13.498182 33.792-33.838546 33.792z m203.101091 473.902546h-135.447273C187.042909 884.317091 139.636364 836.933818 139.636364 782.754909V647.447273c0-20.386909 13.544727-33.838545 33.838545-33.838546s33.885091 13.451636 33.885091 33.838546v135.330909c0 20.293818 13.544727 33.931636 33.838545 33.931636h135.447273c20.270545 0 33.815273 13.451636 33.815273 33.745455-0.046545 20.340364-13.591273 33.885091-33.885091 33.885091z m406.178909 0H647.447273c-20.386909 0-33.931636-13.544727-33.931637-33.931636 0-20.293818 13.544727-33.745455 33.931637-33.745455h135.330909c20.386909 0 33.838545-13.637818 33.838545-33.931636V647.447273c0-20.386909 13.544727-33.838545 33.931637-33.838546 20.293818 0 33.838545 13.451636 33.838545 33.838546v135.330909c-0.046545 54.178909-47.522909 101.562182-101.608727 101.562182z m67.723636-473.902546c-20.386909 0-33.931636-13.498182-33.931636-33.792v-135.377454c0-20.340364-13.451636-33.885091-33.838545-33.885091H647.447273c-20.386909 0-33.931636-13.498182-33.931637-33.838545S627.083636 139.636364 647.424 139.636364h135.330909c54.085818 0 101.562182 47.429818 101.562182 101.608727v135.377454c0 20.293818-13.544727 33.792-33.838546 33.792z m0 135.493819H173.474909c-20.293818 0-33.838545-13.591273-33.838545-33.931637s13.544727-33.885091 33.838545-33.885091h677.003636c20.293818 0 33.838545 13.591273 33.838546 33.885091s-13.544727 33.931636-33.838546 33.931637z" fill="#8a8a8a" p-id="7780"></path></svg>`;
+
+/**
+ * planner 图标 SVG
+ */
+export const plannerIconSvg = `<svg t="1767143425474" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="10954" width="16" height="16"><path d="M860.544 633.856c-82.368 0-152.128 69.632-158.464 152h-354.88c-31.616 0-63.296-31.68-63.296-63.296V437.376c12.608 0 25.344 6.4 44.288 6.4h380.16c12.672 69.696 76.032 126.656 152.128 126.656 88.704 0 158.336-69.696 158.336-158.4s-69.632-158.4-158.336-158.4c-76.096 0-139.456 57.024-152.128 126.656h-361.216c-31.616 0-63.296-31.68-63.296-63.296v-133.12h164.736c31.68 0 63.296-22.848 63.296-54.528a55.04 55.04 0 0 0-56-56h-380.16c-31.68 0-70.72 17.984-70.72 56s31.68 54.528 63.36 54.528h133.056v538.624c0 69.696 57.088 126.656 126.72 126.656h386.56c25.344 57.088 82.368 101.376 145.728 101.376a156.8 156.8 0 0 0 158.336-158.4 156.608 156.608 0 0 0-158.208-158.272z m0-316.8c50.624 0 94.912 44.288 94.912 94.976s-44.288 94.976-94.912 94.976c-50.752 0-95.104-44.288-95.104-94.976s44.352-94.976 95.104-94.976z m0 570.24c-50.752 0-95.104-44.352-95.104-95.04s44.352-95.04 95.104-95.04c50.624 0 94.912 44.352 94.912 95.04s-44.288 95.04-94.912 95.04z" p-id="10955" fill="#8a8a8a"></path></svg>`;
+
+/**
+ * Ask 模式图标 SVG
+ */
+export const askIconSvg = `<svg t="1767143500000" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" width="16" height="16"><path d="M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64z m0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" fill="#8a8a8a"/><path d="M623.6 316.7C593.6 290.4 554 276 512 276s-81.6 14.5-111.6 40.7C369.2 344 352 380.7 352 420.4c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8 0-25.6 10.1-49.4 28.4-67.2 18.7-18.2 43.4-28.2 71.6-28.2s52.9 10 71.6 28.2c18.3 17.8 28.4 41.6 28.4 67.2 0 29.5-12.2 55.3-36.2 76.6-23.2 20.6-61.1 45.9-82.2 60.6-17.8 12.4-28.6 32.7-28.6 54.2V640c0 4.4 3.6 8 8 8h48c4.4 0 8-3.6 8-8v-35.8c0-4.1 2.6-7.8 6.5-9.2 31.3-11.6 84.8-40.6 113.8-64.8 42.6-35.6 66.2-83.5 66.2-134.8 0-39.7-17.2-76.4-48.4-103.3z" fill="#8a8a8a"/><path d="M512 716m-40 0a40 40 0 1 0 80 0 40 40 0 1 0-80 0Z" fill="#8a8a8a"/></svg>`;
+
+/**
+ * 保存知识库图标 SVG
+ */
+export const saveKnowledgeIconSvg = `
+  <span class="tool-save-knowledge-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M827.733333 315.733333l-123.733333-123.733333c-12.8-12.8-34.133333-21.333333-59.733333-21.333334H256c-46.96 0-85.44 40.96-85.44 85.44v512c0 46.96 40.96 85.44 85.44 85.44h512c46.96 0 85.44-40.96 85.44-85.44V375.466667c0-25.6-8.533333-46.933333-21.333333-59.733334z m-140.8 469.333334H337.066667v-85.333334h349.866666v85.333334z m0-170.666667H337.066667v-85.333333h349.866666v85.333333z m0-170.666667H337.066667v-85.333333h349.866666v85.333333z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 文件读取图标 SVG
+ */
+export const fileReadIconSvg = `
+  <span class="tool-file-read-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM790.2 326H602V137.8L790.2 326z m1.8 562H232V136h302v216c0 23.2 18.8 42 42 42h216v494z" fill="#8a8a8a"/>
+      <path d="M342 472h340c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H342c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8zM342 616h340c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H342c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8zM342 760h340c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H342c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 文件删除图标 SVG
+ */
+export const fileDeleteIconSvg = `
+  <span class="tool-file-delete-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M360 184h-8c4.4 0 8-3.6 8-8v8h304v-8c0 4.4 3.6 8 8 8h-8v72h72v-80c0-35.3-28.7-64-64-64H352c-35.3 0-64 28.7-64 64v80h72v-72z" fill="#8a8a8a"/>
+      <path d="M832 256H192c-17.7 0-32 14.3-32 32v32c0 4.4 3.6 8 8 8h60.4l24.7 523c1.6 34.1 29.8 61 63.9 61h454c34.2 0 62.3-26.8 63.9-61l24.7-523H888c4.4 0 8-3.6 8-8v-32c0-17.7-14.3-32-32-32zM731.3 840H292.7l-24.2-512h487l-24.2 512z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 仿真图标 SVG
+ */
+export const simulationIconSvg = `
+  <span class="tool-simulation-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M928 160H96c-17.7 0-32 14.3-32 32v640c0 17.7 14.3 32 32 32h832c17.7 0 32-14.3 32-32V192c0-17.7-14.3-32-32-32z m-40 632H136V232h752v560z" fill="#8a8a8a"/>
+      <path d="M210 304h100c4.4 0 8 3.6 8 8v152c0 4.4-3.6 8-8 8H210c-4.4 0-8-3.6-8-8V312c0-4.4 3.6-8 8-8zM210 544h100c4.4 0 8 3.6 8 8v152c0 4.4-3.6 8-8 8H210c-4.4 0-8-3.6-8-8V552c0-4.4 3.6-8 8-8zM462 304h100c4.4 0 8 3.6 8 8v152c0 4.4-3.6 8-8 8H462c-4.4 0-8-3.6-8-8V312c0-4.4 3.6-8 8-8zM462 544h100c4.4 0 8 3.6 8 8v152c0 4.4-3.6 8-8 8H462c-4.4 0-8-3.6-8-8V552c0-4.4 3.6-8 8-8zM714 304h100c4.4 0 8 3.6 8 8v152c0 4.4-3.6 8-8 8H714c-4.4 0-8-3.6-8-8V312c0-4.4 3.6-8 8-8zM714 544h100c4.4 0 8 3.6 8 8v152c0 4.4-3.6 8-8 8H714c-4.4 0-8-3.6-8-8V552c0-4.4 3.6-8 8-8z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 波形分析图标 SVG
+ */
+export const waveformIconSvg = `
+  <span class="tool-waveform-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M952 474H829.8C812.5 327.6 696.4 211.5 550 194.2V72c0-4.4-3.6-8-8-8h-60c-4.4 0-8 3.6-8 8v122.2C327.6 211.5 211.5 327.6 194.2 474H72c-4.4 0-8 3.6-8 8v60c0 4.4 3.6 8 8 8h122.2C211.5 696.4 327.6 812.5 474 829.8V952c0 4.4 3.6 8 8 8h60c4.4 0 8-3.6 8-8V829.8C696.4 812.5 812.5 696.4 829.8 550H952c4.4 0 8-3.6 8-8v-60c0-4.4-3.6-8-8-8zM512 756c-134.8 0-244-109.2-244-244s109.2-244 244-244 244 109.2 244 244-109.2 244-244 244z" fill="#8a8a8a"/>
+      <path d="M512 392c-32.1 0-62.1 12.4-84.8 35.2-22.7 22.7-35.2 52.7-35.2 84.8s12.5 62.1 35.2 84.8c22.7 22.7 52.7 35.2 84.8 35.2s62.1-12.5 84.8-35.2c22.7-22.7 35.2-52.7 35.2-84.8s-12.5-62.1-35.2-84.8C574.1 404.4 544.1 392 512 392z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 知识库加载图标 SVG
+ */
+export const knowledgeLoadIconSvg = `
+  <span class="tool-knowledge-load-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M880 112H144c-17.7 0-32 14.3-32 32v736c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V144c0-17.7-14.3-32-32-32z m-40 728H184V184h656v656z" fill="#8a8a8a"/>
+      <path d="M492 400h184c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H492c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8zM492 544h184c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H492c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8zM492 688h184c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H492c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8zM340 368a40 40 0 1 0 80 0 40 40 0 1 0-80 0zM340 512a40 40 0 1 0 80 0 40 40 0 1 0-80 0zM340 656a40 40 0 1 0 80 0 40 40 0 1 0-80 0z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 状态转换图标 SVG
+ */
+export const stateTransitionIconSvg = `
+  <span class="tool-state-transition-icon">
+    <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+      <path d="M512 64C264.6 64 64 264.6 64 512s200.6 448 448 448 448-200.6 448-448S759.4 64 512 64z m0 820c-205.4 0-372-166.6-372-372s166.6-372 372-372 372 166.6 372 372-166.6 372-372 372z" fill="#8a8a8a"/>
+      <path d="M686.7 638.6L544.1 535.5V288c0-4.4-3.6-8-8-8h-48c-4.4 0-8 3.6-8 8v275.4c0 2.6 1.2 5 3.3 6.5l165.4 120.6c3.6 2.6 8.6 1.8 11.2-1.7l28.6-39c2.6-3.7 1.8-8.7-1.9-11.2z" fill="#8a8a8a"/>
+      <path d="M512 320c-4.4 0-8 3.6-8 8v184c0 4.4 3.6 8 8 8h184c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8H560V328c0-4.4-3.6-8-8-8h-40z" fill="#8a8a8a"/>
+    </svg>
+  </span>
+`;
+
+/**
+ * 用户提问图标 SVG
+ */
+export const userQuestionIconSvg = `<svg t="1767869230062" class="icon" viewBox="0 0 1068 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="4819" width="14" height="14"><path d="M563.645217 578.782609c2.537739-35.350261 6.322087-58.189913 11.397566-68.518957 7.568696-15.449043 24.175304-34.370783 49.775304-56.631652 35.172174-30.72 58.546087-53.960348 70.121739-69.810087 11.575652-15.805217 17.408-36.418783 17.408-61.885217 0-41.939478-15.805217-76.399304-47.37113-103.379479-31.610435-26.980174-73.638957-40.470261-126.130087-40.47026-56.765217 0-101.376 15.760696-133.921392 47.282086C372.424348 256.934957 356.173913 298.562783 356.173913 350.386087h71.145739c1.335652-31.165217 6.811826-55.02887 16.384-71.590957 17.051826-29.740522 47.86087-44.610783 92.338087-44.610782 35.973565 0 61.796174 8.637217 77.378783 25.911652 15.582609 17.274435 23.373913 37.665391 23.373913 61.128348 0 16.784696-5.342609 32.990609-16.027826 48.573217-5.787826 8.904348-13.534609 17.363478-23.151305 25.555478l-31.966608 28.40487c-30.675478 27.113739-50.487652 51.155478-59.570087 72.125217-6.054957 13.979826-10.551652 41.627826-13.579131 82.899479h71.145739z m15.137392 89.043478a44.521739 44.521739 0 1 0-89.043479 0 44.521739 44.521739 0 0 0 89.043479 0z" fill="#8a8a8a" p-id="4820"></path><path d="M934.912 0h-801.391304a133.565217 133.565217 0 0 0-133.565218 133.565217v623.304348l0.222609 7.835826A133.565217 133.565217 0 0 0 133.565217 890.434783h222.608696v89.043478a44.521739 44.521739 0 0 0 64.556522 39.713391L675.661913 890.434783h259.294609a133.565217 133.565217 0 0 0 133.565217-133.565218V133.565217a133.565217 133.565217 0 0 0-133.565217-133.565217z m-801.391304 89.043478h801.391304a44.521739 44.521739 0 0 1 44.521739 44.521739v623.304348a44.521739 44.521739 0 0 1-44.521739 44.521739h-269.801739a44.521739 44.521739 0 0 0-20.034783 4.763826l-199.902608 100.930783V845.913043a44.521739 44.521739 0 0 0-44.52174-44.521739h-267.130434a44.521739 44.521739 0 0 1-44.521739-44.521739V133.565217a44.521739 44.521739 0 0 1 44.521739-44.521739z" fill="#8a8a8a" p-id="4821"></path></svg>`;
+
+/**
+ * 用户头像图标 SVG
+ */
+export const userAvatarIconSvg = `<svg t="1767947405083" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="4661" width="16" height="16"><path d="M515.541449 7.082899c-280.359429 0-508.458551 228.120391-508.458551 508.458551s228.120391 508.458551 508.458551 508.458551 508.458551-228.120391 508.458551-508.458551S795.900879 7.082899 515.541449 7.082899zM515.541449 981.864196c-257.132626 0-466.301477-209.190121-466.301477-466.322747 0-257.132626 209.168851-466.322747 466.301477-466.322747s466.301477 209.190121 466.301477 466.322747S772.674075 981.864196 515.541449 981.864196zM614.574414 524.177056 614.574414 524.177056c47.751075-31.96876 79.230625-86.398604 79.230625-148.187857 0-98.437405-79.804915-178.24232-178.24232-178.24232-98.437405 0-178.24232 79.804915-178.24232 178.24232 0 61.810523 31.479551 116.219097 79.251895 148.187857-100.266622 39.519598-171.244501 137.170014-171.244501 251.453545 0 0.23397 0 0.446669 0.02127 0.659369 0 0.04254-0.02127 0.10635-0.02127 0.14889 0 15.612155 12.65563 28.246516 28.267786 28.246516 15.590885 0 21.886796-12.63436 21.886796-28.246516 0-0.340319-0.08508-0.659369-0.10635-1.020958 0.10635-118.005774 102.159649-219.995264 220.207964-219.995264 118.112124 0 220.207964 102.095839 220.207964 220.207964 0 0.14889-1.467628 29.054774 21.971875 29.054774 15.505806 0 28.076356-12.57055 28.076356-28.055086 0-0.06381-0.02127-0.12762-0.02127-0.2127 0-0.25524 0.02127-0.510479 0.02127-0.786989C785.797645 661.34707 714.798496 563.696654 614.574414 524.177056zM515.541449 510.734437c-74.402343 0-134.723968-60.321625-134.723968-134.723968 0-74.423613 60.321625-134.723968 134.723968-134.723968 74.423613 0 134.723968 60.321625 134.723968 134.723968S589.943792 510.734437 515.541449 510.734437z" fill="currentColor" p-id="4662"></path></svg>`;

src/extension.ts

@@ -1,28 +1,64 @@
 import * as vscode from "vscode";
 import { ICViewProvider } from "./views/ICViewProvider";
 import { showICHelperPanel } from "./panels/ICHelperPanel";
-import { VCDViewerPanel } from "./panels/VCDViewerPanel";
+import { VCDViewerPanel, VCDViewerEditorProvider } from "./panels/VCDViewerPanel";
 import { ChatHistoryManager } from "./utils/chatHistoryManager";
+import { ICCoderAuthenticationProvider } from "./services/icCoderAuthProvider";
+import { VCDFileServer } from "./services/vcdFileServer";
+import { initUserService } from "./services/userService";
 
 export function activate(context: vscode.ExtensionContext) {
   console.log("🎉 IC Coder 插件已激活！");
 
-  // 自动打开聊天面板
+  // 初始化用户服务
-  vscode.commands.executeCommand("ic-coder.openChat");
+  initUserService(context);
+
+  // 初始化 VCD 文件服务器
+  const vcdFileServer = new VCDFileServer(context.extensionUri);
+  vcdFileServer.start().then((port) => {
+    console.log(`VCD 文件服务器已启动，端口: ${port}`);
+  }).catch((error) => {
+    console.error("启动 VCD 文件服务器失败:", error);
+  });
+
+  // 在插件停用时关闭服务器
+  context.subscriptions.push({
+    dispose: () => vcdFileServer.stop()
+  });
+
+  // 注册 Authentication Provider
+  const authProvider = new ICCoderAuthenticationProvider(context);
+  context.subscriptions.push(
+    vscode.authentication.registerAuthenticationProvider(
+      "iccoder",
+      "IC Coder",
+      authProvider
+    )
+  );
+
+  // 检查登录状态，如果已登录则自动打开聊天面板
+  vscode.authentication.getSession("iccoder", [], { createIfNone: false })
+    .then((session) => {
+      if (session) {
+        vscode.commands.executeCommand("ic-coder.openChat");
+      }
+    }, () => {
+      // 未登录，不做任何操作
+    });
 
   // 注册命令：打开助手面板
   const openPanelCommand = vscode.commands.registerCommand(
     "ic-coder.openPanel",
-    () => {
+    async () => {
-      showICHelperPanel(context);
+      await showICHelperPanel(context);
     }
   );
 
   // 注册命令：打开聊天（用于侧边栏）
   const openChatCommand = vscode.commands.registerCommand(
     "ic-coder.openChat",
-    () => {
+    async () => {
-      showICHelperPanel(context);
+      await showICHelperPanel(context);
     }
   );
 
@@ -50,7 +86,74 @@ export function activate(context: vscode.ExtensionContext) {
         }
       }
 
-      VCDViewerPanel.createOrShow(context.extensionUri, vcdFilePath);
+      VCDViewerPanel.createOrShow(context.extensionUri, vcdFilePath, vcdFileServer);
+    }
+  );
+
+  // 注册命令：在浏览器中打开 VCD 波形查看器
+  const openVCDViewerInBrowserCommand = vscode.commands.registerCommand(
+    "ic-coder.openVCDViewerInBrowser",
+    async (vcdFilePath?: string) => {
+      if (!vcdFilePath) {
+        const fileUri = await vscode.window.showOpenDialog({
+          canSelectFiles: true,
+          canSelectFolders: false,
+          canSelectMany: false,
+          filters: {
+            "VCD 文件": ["vcd"],
+            "所有文件": ["*"],
+          },
+          title: "选择 VCD 文件",
+        });
+
+        if (fileUri && fileUri[0]) {
+          vcdFilePath = fileUri[0].fsPath;
+        } else {
+          return;
+        }
+      }
+
+      // 注册文件到服务器
+      const fileId = vcdFileServer.registerFile(vcdFilePath);
+      const viewerUrl = vcdFileServer.getViewerUrl(fileId);
+
+      // 在默认浏览器中打开
+      vscode.env.openExternal(vscode.Uri.parse(viewerUrl));
+      vscode.window.showInformationMessage(`波形查看器已在浏览器中打开`);
+    }
+  );
+
+  // 注册命令：用户登录
+  const loginCommand = vscode.commands.registerCommand(
+    "ic-coder.login",
+    async () => {
+      try {
+        await vscode.authentication.getSession("iccoder", [], { createIfNone: true });
+      } catch (error) {
+        vscode.window.showErrorMessage(`登录失败: ${error}`);
+      }
+    }
+  );
+
+  // 注册命令：用户登出
+  const logoutCommand = vscode.commands.registerCommand(
+    "ic-coder.logout",
+    async () => {
+      try {
+        const session = await vscode.authentication.getSession("iccoder", [], { createIfNone: false });
+        if (session) {
+          // 通过创建新会话并清除偏好来实现登出
+          await vscode.authentication.getSession("iccoder", [], {
+            clearSessionPreference: true,
+            forceNewSession: true
+          });
+          vscode.window.showInformationMessage("已退出登录");
+        } else {
+          vscode.window.showInformationMessage("当前未登录");
+        }
+      } catch (error) {
+        vscode.window.showInformationMessage("当前未登录");
+      }
     }
   );
 
@@ -102,17 +205,23 @@ export function activate(context: vscode.ExtensionContext) {
   */
 
   // 注册侧边栏视图
-  const viewProvider = new ICViewProvider(context.extensionUri);
+  const viewProvider = new ICViewProvider(context.extensionUri, context);
   const viewRegistration = vscode.window.registerWebviewViewProvider(
     "ic-coder.mainView",
     viewProvider
   );
 
+  // 注册 VCD 自定义编辑器
+  const vcdEditorProvider = VCDViewerEditorProvider.register(context, vcdFileServer);
+
   // 添加到订阅
   context.subscriptions.push(
     openPanelCommand,
     openChatCommand,
     openVCDViewerCommand,
+    openVCDViewerInBrowserCommand,
+    loginCommand,
+    logoutCommand,
     // TODO: 等待重新实现这些命令
     // viewHistoryCommand,
     // newSessionCommand,
@@ -120,7 +229,8 @@ export function activate(context: vscode.ExtensionContext) {
     // deleteSessionCommand,
     // clearHistoryCommand,
     // searchSessionCommand,
-    viewRegistration
+    viewRegistration,
+    vcdEditorProvider
   );
 }
 

src/panels/ICHelperPanel.ts

@@ -6,14 +6,90 @@ import {
   handleReadFile,
   handleUpdateFile,
   handleRenameFile,
-  handleReplaceInFile
+  handleReplaceInFile,
+  handleUserAnswer,
+  abortCurrentDialog,
+  handlePlanAction,
+  setPendingPlanExecution,
+  getCurrentTaskId,
+  setLastTaskId,
 } from "../utils/messageHandler";
+import { compactDialog } from "../services/apiClient";
 import { VCDViewerPanel } from "./VCDViewerPanel";
+import { ChatHistoryManager } from "../utils/chatHistoryManager";
+import { MessageType } from "../types/chatHistory";
+import { getCachedUserInfo } from "../services/userService";
+
+/**
+ * 获取会员等级图标 URI
+ */
+function getTierIconUri(
+  webview: vscode.Webview,
+  context: vscode.ExtensionContext,
+  tierCode?: string
+): string | undefined {
+  if (!tierCode) {
+    return undefined;
+  }
+
+  const tierIconMap: Record<string, string> = {
+    BASIC: "free.png",
+    TRIAL: "PRO-Try.png",
+    ADVANCED: "PRO.png",
+    PROFESSIONAL: "PRO+.png",
+  };
+
+  const iconFile = tierIconMap[tierCode];
+  if (!iconFile) {
+    return undefined;
+  }
+
+  const iconUri = webview.asWebviewUri(
+    vscode.Uri.joinPath(
+      context.extensionUri,
+      "src",
+      "assets",
+      "titleIcon",
+      iconFile
+    )
+  );
+
+  return iconUri.toString();
+}
 
 /**
  * 创建并显示 IC 助手面板
  */
-export function showICHelperPanel(context: vscode.ExtensionContext, viewColumn?: vscode.ViewColumn) {
+export async function showICHelperPanel(
+  context: vscode.ExtensionContext,
+  viewColumn?: vscode.ViewColumn
+) {
+  // 检查用户是否已登录
+  try {
+    const session = await vscode.authentication.getSession("iccoder", [], {
+      createIfNone: false,
+    });
+    if (!session) {
+      vscode.window
+        .showWarningMessage("请先登录后再使用 IC Coder", "立即登录")
+        .then((selection) => {
+          if (selection === "立即登录") {
+            vscode.commands.executeCommand("ic-coder.login");
+          }
+        });
+      return;
+    }
+  } catch (error) {
+    vscode.window
+      .showWarningMessage("请先登录后再使用 IC Coder", "立即登录")
+      .then((selection) => {
+        if (selection === "立即登录") {
+          vscode.commands.executeCommand("ic-coder.login");
+        }
+      });
+    return;
+  }
+
   // 创建WebView面板
   const panel = vscode.window.createWebviewPanel(
     "icCoder", // 面板ID
@@ -22,27 +98,167 @@ export function showICHelperPanel(context: vscode.ExtensionContext, viewColumn?:
     {
       enableScripts: true,
       retainContextWhenHidden: true,
-      localResourceRoots: [vscode.Uri.joinPath(context.extensionUri, "media")],
+      localResourceRoots: [
+        vscode.Uri.joinPath(context.extensionUri, "media"),
+        vscode.Uri.joinPath(context.extensionUri, "src", "assets"),
+      ],
     }
   );
 
+  // 为面板生成唯一ID
+  const panelId = `panel_${Date.now()}_${Math.random()
+    .toString(36)
+    .substr(2, 9)}`;
+  (panel as any).__uniqueId = panelId;
+
   // 设置标签页图标
-  panel.iconPath = vscode.Uri.joinPath(context.extensionUri, "media", "图案（方底）.png");
+  panel.iconPath = vscode.Uri.joinPath(
+    context.extensionUri,
+    "media",
+    "icon.png"
+  );
 
   // 获取页面内图标URI
   const iconUri = panel.webview.asWebviewUri(
-    vscode.Uri.joinPath(context.extensionUri, "media", "图案（方底）.png")
+    vscode.Uri.joinPath(context.extensionUri, "media", "icon.png")
+  );
+
+  // 获取模型图标URI
+  const autoIconUri = panel.webview.asWebviewUri(
+    vscode.Uri.joinPath(
+      context.extensionUri,
+      "src",
+      "assets",
+      "model",
+      "Auto.png"
+    )
+  );
+  const liteIconUri = panel.webview.asWebviewUri(
+    vscode.Uri.joinPath(
+      context.extensionUri,
+      "src",
+      "assets",
+      "model",
+      "lite.png"
+    )
+  );
+  const syIconUri = panel.webview.asWebviewUri(
+    vscode.Uri.joinPath(
+      context.extensionUri,
+      "src",
+      "assets",
+      "model",
+      "Sy.png"
+    )
+  );
+  const maxIconUri = panel.webview.asWebviewUri(
+    vscode.Uri.joinPath(
+      context.extensionUri,
+      "src",
+      "assets",
+      "model",
+      "Max.png"
+    )
   );
 
   // 设置HTML内容
-  panel.webview.html = getWebviewContent(iconUri.toString());
+  panel.webview.html = getWebviewContent(
+    iconUri.toString(),
+    autoIconUri.toString(),
+    liteIconUri.toString(),
+    syIconUri.toString(),
+    maxIconUri.toString()
+  );
+
+  // 获取并发送用户信息到 webview
+  try {
+    // 优先使用缓存的用户信息
+    let userInfo = getCachedUserInfo();
+
+    if (userInfo) {
+      // 使用缓存的用户信息
+      console.log("[ICHelperPanel] 使用缓存的用户信息:", userInfo);
+      const tierIconUrl = getTierIconUri(
+        panel.webview,
+        context,
+        userInfo.membership?.tierCode
+      );
+      panel.webview.postMessage({
+        command: "updateUserInfo",
+        userInfo: {
+          userId: userInfo.userId,
+          nickname: userInfo.nickname,
+          username: userInfo.username,
+        },
+        tierIconUrl: tierIconUrl,
+      });
+    } else {
+      // 如果没有缓存，从 session 中获取
+      const session = await vscode.authentication.getSession("iccoder", [], {
+        createIfNone: false,
+      });
+      if (session) {
+        console.log(
+          "[ICHelperPanel] 从 session 获取用户信息, account:",
+          session.account
+        );
+        panel.webview.postMessage({
+          command: "updateUserInfo",
+          userInfo: {
+            userId: session.account.id,
+            nickname: session.account.label,
+            username: session.account.label,
+          },
+        });
+      }
+    }
+  } catch (error) {
+    console.error("[ICHelperPanel] 获取用户信息失败:", error);
+  }
 
   // 处理消息
   panel.webview.onDidReceiveMessage(
-    (message) => {
+    async (message) => {
+      const historyManager = ChatHistoryManager.getInstance();
+      const panelId = (panel as any).__uniqueId;
+
       switch (message.command) {
         case "sendMessage":
-          handleUserMessage(panel, message.text, context.extensionPath);
+          // 仅在用户发送消息时，确保面板有任务上下文
+          // 如果没有，则创建新任务（仅在首次发送消息时）
+          if (!historyManager.getPanelTask(panelId)) {
+            const workspacePath =
+              vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+            if (workspacePath) {
+              try {
+                const taskMeta = await historyManager.createTask(
+                  workspacePath,
+                  "新对话"
+                );
+                historyManager.setPanelTask(
+                  panelId,
+                  taskMeta.taskId,
+                  workspacePath
+                );
+              } catch (error) {
+                console.error("创建任务失败:", error);
+              }
+            }
+          }
+
+          // 切换到当前面板的任务上下文
+          historyManager.switchToPanelTask(panelId);
+
+          // 显示进度条
+          panel.webview.postMessage({ type: "showProgress" });
+
+          handleUserMessage(
+            panel,
+            message.text,
+            context.extensionPath,
+            message.mode,
+            message.model // 传递服务等级
+          );
           break;
         case "readFile":
           handleReadFile(panel, message.filePath);
@@ -54,7 +270,12 @@ export function showICHelperPanel(context: vscode.ExtensionContext, viewColumn?:
           handleRenameFile(panel, message.oldPath, message.newPath);
           break;
         case "replaceInFile":
-          handleReplaceInFile(panel, message.filePath, message.searchText, message.replaceText);
+          handleReplaceInFile(
+            panel,
+            message.filePath,
+            message.searchText,
+            message.replaceText
+          );
           break;
         case "insertCode":
           insertCodeToEditor(message.code);
@@ -63,9 +284,12 @@ export function showICHelperPanel(context: vscode.ExtensionContext, viewColumn?:
           vscode.window.showInformationMessage(message.text);
           break;
         case "openWaveformViewer":
-          // 打开波形查看器
+          // 在新列中打开波形查看器
           if (message.vcdFilePath) {
-            VCDViewerPanel.createOrShow(context.extensionUri, message.vcdFilePath);
+            vscode.commands.executeCommand(
+              "ic-coder.openVCDViewer",
+              message.vcdFilePath
+            );
           }
           break;
         case "getVCDInfo":
@@ -79,20 +303,264 @@ export function showICHelperPanel(context: vscode.ExtensionContext, viewColumn?:
           showICHelperPanel(context, panel.viewColumn);
           break;
         case "loadConversationHistory":
-          // 加载会话历史（暂未实现）
+          // 加载会话历史（支持分页）
-          panel.webview.postMessage({
+          loadConversationHistory(
-            command: 'conversationHistory',
+            panel,
-            history: []
+            message.offset || 0,
-          });
+            message.limit || 10
+          );
           break;
         case "selectConversation":
-          // 选择会话（暂未实现）
+          // 选择会话
+          if (message.conversationId) {
+            selectConversation(
+              panel,
+              message.conversationId,
+              context.extensionPath
+            );
+          }
+          break;
+        // 新增：处理用户回答
+        case "submitAnswer":
+          handleUserAnswer(
+            message.askId,
+            message.selected,
+            message.customInput
+          );
+          break;
+        // 新增：中止对话
+        case "abortDialog":
+          void abortCurrentDialog();
+          break;
+        // 新增：压缩会话
+        case "compressConversation":
+          {
+            const taskId = getCurrentTaskId();
+            if (taskId) {
+              compactDialog(taskId)
+                .then((result) => {
+                  if (result.success) {
+                    panel.webview.postMessage({
+                      command: "receiveMessage",
+                      text: "✅ 会话压缩完成",
+                    });
+                  } else {
+                    panel.webview.postMessage({
+                      command: "receiveMessage",
+                      text: `❌ 压缩失败: ${result.error || "未知错误"}`,
+                    });
+                  }
+                })
+                .catch((err) => {
+                  panel.webview.postMessage({
+                    command: "receiveMessage",
+                    text: `❌ 压缩失败: ${err.message || "网络错误"}`,
+                  });
+                });
+            } else {
+              panel.webview.postMessage({
+                command: "receiveMessage",
+                text: "❌ 没有活跃的会话",
+              });
+            }
+          }
+          break;
+        // 处理计划操作（只做模式切换，响应已通过 submitAnswer 发送）
+        case "planAction":
+          if (message.action === "confirm") {
+            // 确认执行：切换到 Agent 模式
+            panel.webview.postMessage({
+              command: "switchMode",
+              mode: "agent",
+            });
+            // 获取当前会话的 taskId，用于复用知识图谱数据
+            const taskId = getCurrentTaskId();
+            if (taskId) {
+              // 设置待执行的计划，对话结束后自动执行（复用 taskId）
+              setPendingPlanExecution(
+                panel,
+                message.planTitle || "计划",
+                context.extensionPath,
+                taskId
+              );
+            } else {
+              console.warn(
+                "[ICHelperPanel] 无法获取当前 taskId，知识图谱数据可能丢失"
+              );
+            }
+          }
+          break;
+        // 添加文件上下文 - 显示工作区文件列表
+        case "addContextFile":
+          {
+            const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+            if (!workspaceFolder) {
+              vscode.window.showWarningMessage("请先打开一个工作区");
+              break;
+            }
+
+            // 获取工作区所有文件
+            const files = await vscode.workspace.findFiles(
+              "**/*",
+              "**/node_modules/**"
+            );
+
+            panel.webview.postMessage({
+              command: "showWorkspaceFileList",
+              files: files.map((uri) => ({
+                path: uri.fsPath,
+                relativePath: vscode.workspace.asRelativePath(uri),
+              })),
+            });
+          }
+          break;
+        // 添加文件夹上下文 - 显示工作区文件夹列表
+        case "addContextFolder":
+          {
+            const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+            if (!workspaceFolder) {
+              vscode.window.showWarningMessage("请先打开一个工作区");
+              break;
+            }
+
+            // 获取工作区所有文件夹
+            const fs = require("fs");
+            const path = require("path");
+            const folders: Array<{ path: string; relativePath: string }> = [];
+
+            function scanFolders(dir: string, baseDir: string) {
+              try {
+                const items = fs.readdirSync(dir, { withFileTypes: true });
+                for (const item of items) {
+                  if (
+                    item.isDirectory() &&
+                    item.name !== "node_modules" &&
+                    !item.name.startsWith(".")
+                  ) {
+                    const fullPath = path.join(dir, item.name);
+                    const relativePath = path.relative(baseDir, fullPath);
+                    folders.push({ path: fullPath, relativePath });
+                    scanFolders(fullPath, baseDir);
+                  }
+                }
+              } catch (error) {
+                console.error("扫描文件夹失败:", error);
+              }
+            }
+
+            scanFolders(workspaceFolder.uri.fsPath, workspaceFolder.uri.fsPath);
+
+            panel.webview.postMessage({
+              command: "showWorkspaceFolderList",
+              folders: folders,
+            });
+          }
+          break;
+        // 添加图片上下文
+        case "addContextImage":
+          {
+            const imageUris = await vscode.window.showOpenDialog({
+              canSelectFiles: true,
+              canSelectFolders: false,
+              canSelectMany: true,
+              openLabel: "选择图片",
+              filters: {
+                图片文件: ["png", "jpg", "jpeg", "gif", "bmp", "svg", "webp"],
+              },
+            });
+            if (imageUris && imageUris.length > 0) {
+              panel.webview.postMessage({
+                command: "contextImagesSelected",
+                images: imageUris.map((uri) => uri.fsPath),
+              });
+            }
+          }
+          break;
+        // 添加文档库上下文
+        case "addContextDocument":
+          {
+            const docUris = await vscode.window.showOpenDialog({
+              canSelectFiles: true,
+              canSelectFolders: false,
+              canSelectMany: true,
+              openLabel: "选择文档",
+              filters: {
+                文档文件: ["pdf", "doc", "docx", "txt", "md"],
+                所有文件: ["*"],
+              },
+            });
+            if (docUris && docUris.length > 0) {
+              panel.webview.postMessage({
+                command: "contextDocumentsSelected",
+                documents: docUris.map((uri) => uri.fsPath),
+              });
+            }
+          }
+          break;
+        // 新增：检查工作区状态
+        case "checkWorkspace":
+          const hasWorkspace = !!(
+            vscode.workspace.workspaceFolders &&
+            vscode.workspace.workspaceFolders.length > 0
+          );
+          if (!hasWorkspace) {
+            // 弹窗提示用户需要打开工作区
+            vscode.window
+              .showWarningMessage(
+                "请先打开一个文件夹作为工作区，这样我就能更好地为您服务了 😊",
+                "打开文件夹"
+              )
+              .then((selection) => {
+                if (selection === "打开文件夹") {
+                  vscode.commands.executeCommand("vscode.openFolder");
+                }
+              });
+          }
+          // 返回工作区状态给前端
+          panel.webview.postMessage({
+            command: "workspaceStatus",
+            hasWorkspace: hasWorkspace,
+          });
+          break;
+        // 新增：处理面板宽度不足
+        case "panelWidthInsufficient":
+          // 关闭面板
+          panel.dispose();
+          vscode.window.showWarningMessage(
+            "聊天面板宽度不足（最小 200px），已自动关闭"
+          );
           break;
       }
     },
     undefined,
     context.subscriptions
   );
+
+  // 监听面板状态变化，检查宽度
+  panel.onDidChangeViewState(
+    (e) => {
+      if (e.webviewPanel.visible) {
+        // 请求前端检查宽度
+        panel.webview.postMessage({
+          command: "checkPanelWidth",
+          minWidth: 200,
+        });
+      }
+    },
+    undefined,
+    context.subscriptions
+  );
+
+  // 面板关闭时清理任务映射
+  panel.onDidDispose(
+    () => {
+      const historyManager = ChatHistoryManager.getInstance();
+      const panelId = (panel as any).__uniqueId;
+      historyManager.removePanelTask(panelId);
+    },
+    undefined,
+    context.subscriptions
+  );
 }
 
 /**
@@ -104,20 +572,24 @@ async function getVCDFileInfo(
   containerId: string
 ) {
   try {
-    const fs = require('fs');
+    const fs = require("fs");
-    const path = require('path');
+    const path = require("path");
+
+    console.log(`[getVCDFileInfo] 开始解析 VCD 文件: ${vcdFilePath}`);
+    console.log(`[getVCDFileInfo] containerId: ${containerId}`);
 
     // 检查文件是否存在
     if (!fs.existsSync(vcdFilePath)) {
+      console.error(`[getVCDFileInfo] 文件不存在: ${vcdFilePath}`);
       panel.webview.postMessage({
         command: "vcdInfo",
         containerId: containerId,
         vcdInfo: {
-          signalCount: 'N/A',
+          signalCount: "N/A",
-          timeRange: 'N/A',
+          timeRange: "N/A",
-          fileSize: 'N/A',
+          fileSize: "N/A",
-          error: '文件不存在'
+          error: "文件不存在",
-        }
+        },
       });
       return;
     }
@@ -125,19 +597,20 @@ async function getVCDFileInfo(
     // 获取文件大小
     const stats = fs.statSync(vcdFilePath);
     const fileSizeKB = stats.size / 1024;
-    const fileSize = fileSizeKB < 1024
+    const fileSize =
-      ? `${fileSizeKB.toFixed(2)} KB`
+      fileSizeKB < 1024
-      : `${(fileSizeKB / 1024).toFixed(2)} MB`;
+        ? `${fileSizeKB.toFixed(2)} KB`
+        : `${(fileSizeKB / 1024).toFixed(2)} MB`;
 
     // 读取 VCD 文件内容
-    const content = fs.readFileSync(vcdFilePath, 'utf-8');
+    const content = fs.readFileSync(vcdFilePath, "utf-8");
 
     // 解析信号数量
     const varMatches = content.match(/\$var/g);
     const signalCount = varMatches ? varMatches.length : 0;
 
     // 解析时间范围
-    let timeRange = 'N/A';
+    let timeRange = "N/A";
     const timeMatch = content.match(/#(\d+)/g);
     if (timeMatch && timeMatch.length > 0) {
       const times = timeMatch.map((t: string) => parseInt(t.substring(1)));
@@ -146,8 +619,14 @@ async function getVCDFileInfo(
       timeRange = `${minTime} - ${maxTime}`;
     }
 
-    // 解析前几个信号的真实数据
+    // 解析信号的真实数据
-    const signals = parseVCDSignals(content, 3); // 只解析前3个信号
+    // 增加到20个信号，以便显示更多波形（平衡性能和完整性）
+    const signals = parseVCDSignals(content, 20);
+
+    console.log(`[getVCDFileInfo] 解析到 ${signals.length} 个有效信号`);
+    signals.forEach((sig, idx) => {
+      console.log(`[getVCDFileInfo] 信号${idx + 1}: ${sig.name}, 值变化数: ${sig.values.length}`);
+    });
 
     // 发送信息回前端
     panel.webview.postMessage({
@@ -157,21 +636,20 @@ async function getVCDFileInfo(
         signalCount: signalCount.toString(),
         timeRange: timeRange,
         fileSize: fileSize,
-        signals: signals // 添加真实信号数据
+        signals: signals, // 添加真实信号数据
-      }
+      },
     });
-
   } catch (error) {
-    console.error('获取 VCD 文件信息失败:', error);
+    console.error("获取 VCD 文件信息失败:", error);
     panel.webview.postMessage({
       command: "vcdInfo",
       containerId: containerId,
       vcdInfo: {
-        signalCount: 'N/A',
+        signalCount: "N/A",
-        timeRange: 'N/A',
+        timeRange: "N/A",
-        fileSize: 'N/A',
+        fileSize: "N/A",
-        error: error instanceof Error ? error.message : '未知错误'
+        error: error instanceof Error ? error.message : "未知错误",
-      }
+      },
     });
   }
 }
@@ -191,9 +669,16 @@ function parseVCDSignals(content: string, maxSignals: number = 3) {
     // 1. 解析信号定义部分
     const varRegex = /\$var\s+(\w+)\s+(\d+)\s+(\S+)\s+([^\$]+?)\s+\$end/g;
     let match;
-    const signalDefs: Array<{ name: string; identifier: string; width: number }> = [];
+    const signalDefs: Array<{
+      name: string;
+      identifier: string;
+      width: number;
+    }> = [];
 
-    while ((match = varRegex.exec(content)) !== null && signalDefs.length < maxSignals) {
+    while (
+      (match = varRegex.exec(content)) !== null &&
+      signalDefs.length < maxSignals
+    ) {
       const width = parseInt(match[2]);
       const identifier = match[3];
       const name = match[4].trim();
@@ -202,7 +687,7 @@ function parseVCDSignals(content: string, maxSignals: number = 3) {
     }
 
     // 2. 找到数据变化部分的起始位置
-    const dumpvarsIndex = content.indexOf('$dumpvars');
+    const dumpvarsIndex = content.indexOf("$dumpvars");
     if (dumpvarsIndex === -1) {
       return signals;
     }
@@ -215,13 +700,13 @@ function parseVCDSignals(content: string, maxSignals: number = 3) {
       let currentTime = 0;
 
       // 分行处理数据
-      const lines = dataSection.split('\n');
+      const lines = dataSection.split("\n");
 
       for (const line of lines) {
         const trimmedLine = line.trim();
 
         // 解析时间戳
-        if (trimmedLine.startsWith('#')) {
+        if (trimmedLine.startsWith("#")) {
           currentTime = parseInt(trimmedLine.substring(1));
           continue;
         }
@@ -229,15 +714,22 @@ function parseVCDSignals(content: string, maxSignals: number = 3) {
         // 解析信号值变化
         // 格式1: 单比特信号 "0!" 或 "1!"
         // 格式2: 多比特信号 "b1010 !"
+        // 转义标识符中的特殊字符
+        const escapedId = signalDef.identifier.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
         if (signalDef.width === 1) {
           // 单比特信号
-          const singleBitMatch = trimmedLine.match(new RegExp(`^([01xz])${signalDef.identifier}$`));
+          const singleBitMatch = trimmedLine.match(
+            new RegExp(`^([01xz])${escapedId}$`)
+          );
           if (singleBitMatch) {
             values.push({ time: currentTime, value: singleBitMatch[1] });
           }
         } else {
           // 多比特信号
-          const multiBitMatch = trimmedLine.match(new RegExp(`^b([01xz]+)\\s+${signalDef.identifier}$`));
+          const multiBitMatch = trimmedLine.match(
+            new RegExp(`^b([01xz]+)\\s+${escapedId}$`)
+          );
           if (multiBitMatch) {
             values.push({ time: currentTime, value: multiBitMatch[1] });
           }
@@ -249,17 +741,262 @@ function parseVCDSignals(content: string, maxSignals: number = 3) {
         }
       }
 
-      signals.push({
+      // 只添加有值变化数据的信号
-        name: signalDef.name,
+      if (values.length > 0) {
-        identifier: signalDef.identifier,
+        signals.push({
-        width: signalDef.width,
+          name: signalDef.name,
-        values: values
+          identifier: signalDef.identifier,
-      });
+          width: signalDef.width,
+          values: values,
+        });
+      }
     }
-
   } catch (error) {
-    console.error('解析 VCD 信号数据失败:', error);
+    console.error("解析 VCD 信号数据失败:", error);
   }
 
   return signals;
 }
+
+/**
+ * 加载会话历史（支持分页）
+ */
+async function loadConversationHistory(
+  panel: vscode.WebviewPanel,
+  offset: number = 0,
+  limit: number = 10
+) {
+  try {
+    const historyManager = ChatHistoryManager.getInstance();
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+
+    if (!workspacePath) {
+      // 没有打开的工作区，返回空历史
+      panel.webview.postMessage({
+        command: "conversationHistory",
+        items: [],
+        total: 0,
+        hasMore: false,
+      });
+      return;
+    }
+
+    // 获取会话历史列表（支持分页）
+    const result = await historyManager.getConversationHistoryList(
+      workspacePath,
+      offset,
+      limit
+    );
+
+    // 发送会话历史到前端
+    panel.webview.postMessage({
+      command: "conversationHistory",
+      items: result.items,
+      total: result.total,
+      hasMore: result.hasMore,
+    });
+  } catch (error) {
+    console.error("加载会话历史失败:", error);
+    // 发生错误时返回空历史
+    panel.webview.postMessage({
+      command: "conversationHistory",
+      items: [],
+      total: 0,
+      hasMore: false,
+    });
+  }
+}
+
+/**
+ * 选择并加载指定的会话
+ */
+async function selectConversation(
+  panel: vscode.WebviewPanel,
+  taskId: string,
+  extensionPath: string
+) {
+  try {
+    const historyManager = ChatHistoryManager.getInstance();
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
+
+    if (!workspacePath) {
+      vscode.window.showErrorMessage("没有打开的工作区");
+      return;
+    }
+
+    // 加载任务会话
+    const taskSession = await historyManager.loadTaskSession(
+      workspacePath,
+      taskId
+    );
+
+    if (!taskSession) {
+      vscode.window.showErrorMessage(
+        `加载任务 ${taskId} 失败: 任务不存在或数据损坏`
+      );
+      return;
+    }
+
+    // 切换到该任务
+    const switched = await historyManager.switchTask(workspacePath, taskId);
+    if (!switched) {
+      vscode.window.showErrorMessage(`切换到任务 ${taskId} 失败`);
+      return;
+    }
+
+    // 设置 lastTaskId，用于压缩等操作
+    setLastTaskId(taskId);
+
+    // 更新面板的任务映射，确保后续对话保存到正确的任务中
+    const panelId = (panel as any).__uniqueId;
+    historyManager.setPanelTask(panelId, taskId, workspacePath);
+
+    // 清空当前聊天界面
+    panel.webview.postMessage({
+      command: "clearChat",
+    });
+
+    // 将会话历史消息转换为 segments 格式并发送到前端显示
+    const segments: any[] = [];
+    let i = 0;
+
+    while (i < taskSession.messages.length) {
+      const message = taskSession.messages[i];
+
+      if (message.type === MessageType.USER) {
+        // 用户消息 - 如果有累积的 segments，先发送
+        if (segments.length > 0) {
+          panel.webview.postMessage({
+            command: "receiveSegments",
+            segments: [...segments],
+          });
+          segments.length = 0;
+        }
+
+        // 发送用户消息
+        const textContent = message.contents?.find((c) => c.type === "TEXT");
+        if (textContent && "text" in textContent) {
+          panel.webview.postMessage({
+            command: "addUserMessage",
+            text: textContent.text,
+          });
+        }
+        i++;
+      } else if (message.type === MessageType.AI) {
+        // AI消息 - 如果有 segments，直接使用
+        if (message.segments && message.segments.length > 0) {
+          panel.webview.postMessage({
+            command: "receiveSegments",
+            segments: message.segments,
+          });
+          i++;
+        } else {
+          // 旧格式：需要转换为 segments
+          // 收集连续的 AI 消息、工具调用和工具结果
+          if (message.text) {
+            segments.push({
+              type: "text",
+              content: message.text,
+            });
+          }
+
+          // 检查是否有工具调用
+          if (
+            message.toolExecutionRequests &&
+            message.toolExecutionRequests.length > 0
+          ) {
+            for (const toolReq of message.toolExecutionRequests) {
+              // 查找对应的工具执行结果
+              let toolResult = "";
+              if (i + 1 < taskSession.messages.length) {
+                const nextMsg = taskSession.messages[i + 1];
+                if (
+                  nextMsg.type === MessageType.TOOL_EXECUTION_RESULT &&
+                  nextMsg.id === toolReq.id
+                ) {
+                  toolResult = nextMsg.text;
+                  i++; // 跳过工具结果消息
+                }
+              }
+
+              segments.push({
+                type: "tool",
+                toolName: toolReq.name,
+                askId: toolReq.id,
+                toolResult: toolResult,
+              });
+            }
+          }
+
+          i++;
+
+          // 继续收集后续的 AI 消息，直到遇到用户消息或有 segments 的 AI 消息
+          while (i < taskSession.messages.length) {
+            const nextMsg = taskSession.messages[i];
+            if (nextMsg.type === MessageType.USER) {
+              break;
+            }
+            if (nextMsg.type === MessageType.AI) {
+              if (nextMsg.segments && nextMsg.segments.length > 0) {
+                break;
+              }
+              if (nextMsg.text) {
+                segments.push({
+                  type: "text",
+                  content: nextMsg.text,
+                });
+              }
+              if (
+                nextMsg.toolExecutionRequests &&
+                nextMsg.toolExecutionRequests.length > 0
+              ) {
+                for (const toolReq of nextMsg.toolExecutionRequests) {
+                  let toolResult = "";
+                  if (i + 1 < taskSession.messages.length) {
+                    const resultMsg = taskSession.messages[i + 1];
+                    if (
+                      resultMsg.type === MessageType.TOOL_EXECUTION_RESULT &&
+                      resultMsg.id === toolReq.id
+                    ) {
+                      toolResult = resultMsg.text;
+                      i++; // 跳过工具结果消息
+                    }
+                  }
+                  segments.push({
+                    type: "tool",
+                    toolName: toolReq.name,
+                    askId: toolReq.id,
+                    toolResult: toolResult,
+                  });
+                }
+              }
+              i++;
+            } else if (nextMsg.type === MessageType.TOOL_EXECUTION_RESULT) {
+              // 独立的工具结果（没有被上面处理的）
+              i++;
+            } else {
+              i++;
+            }
+          }
+        }
+      } else {
+        i++;
+      }
+    }
+
+    // 发送剩余的 segments
+    if (segments.length > 0) {
+      panel.webview.postMessage({
+        command: "receiveSegments",
+        segments: segments,
+      });
+    }
+
+    vscode.window.showInformationMessage(
+      `已加载会话: ${taskSession.meta.taskName}`
+    );
+  } catch (error) {
+    console.error("选择会话失败:", error);
+    vscode.window.showErrorMessage(`加载会话失败: ${error}`);
+  }
+}

src/panels/VCDViewerPanel.ts

@@ -1,19 +1,77 @@
 import * as vscode from "vscode";
 import * as path from "path";
 import * as fs from "fs";
+import { VCDFileServer } from "../services/vcdFileServer";
 
 /**
- * VCD 波形查看器面板
+ * VCD 波形查看器自定义编辑器提供者
+ */
+export class VCDViewerEditorProvider implements vscode.CustomReadonlyEditorProvider {
+  public static register(context: vscode.ExtensionContext, vcdFileServer: VCDFileServer): vscode.Disposable {
+    const provider = new VCDViewerEditorProvider(context, vcdFileServer);
+    const providerRegistration = vscode.window.registerCustomEditorProvider(
+      "ic-coder.vcdViewer",
+      provider,
+      {
+        webviewOptions: {
+          retainContextWhenHidden: true,
+        },
+      }
+    );
+    return providerRegistration;
+  }
+
+  constructor(
+    private readonly context: vscode.ExtensionContext,
+    private readonly vcdFileServer: VCDFileServer
+  ) {}
+
+  async openCustomDocument(
+    uri: vscode.Uri,
+    openContext: vscode.CustomDocumentOpenContext,
+    token: vscode.CancellationToken
+  ): Promise<vscode.CustomDocument> {
+    return {
+      uri,
+      dispose: () => {},
+    };
+  }
+
+  async resolveCustomEditor(
+    document: vscode.CustomDocument,
+    webviewPanel: vscode.WebviewPanel,
+    token: vscode.CancellationToken
+  ): Promise<void> {
+    webviewPanel.webview.options = {
+      enableScripts: true,
+      localResourceRoots: [this.context.extensionUri],
+    };
+
+    // 使用公共工厂方法创建 VCD 查看器实例
+    VCDViewerPanel.createFromWebviewPanel(
+      webviewPanel,
+      this.context.extensionUri,
+      document.uri.fsPath,
+      this.vcdFileServer
+    );
+  }
+}
+
+/**
+ * VCD 波形查看器面板 (使用 Surfer)
  */
 export class VCDViewerPanel {
   public static currentPanel: VCDViewerPanel | undefined;
   private readonly _panel: vscode.WebviewPanel;
   private readonly _extensionUri: vscode.Uri;
   private _disposables: vscode.Disposable[] = [];
+  private _currentVcdPath: string | undefined;
+  private _vcdFileServer: VCDFileServer | undefined;
 
-  private constructor(panel: vscode.WebviewPanel, extensionUri: vscode.Uri) {
+  private constructor(panel: vscode.WebviewPanel, extensionUri: vscode.Uri, vcdFileServer?: VCDFileServer) {
     this._panel = panel;
     this._extensionUri = extensionUri;
+    this._vcdFileServer = vcdFileServer;
 
     // 设置初始 HTML 内容
     this._panel.webview.html = this._getLoadingHtml();
@@ -24,12 +82,20 @@ export class VCDViewerPanel {
     // 监听来自 webview 的消息
     this._panel.webview.onDidReceiveMessage(
       (message) => {
+        console.log("[VCDViewerPanel] 收到消息:", message);
         switch (message.command) {
           case "loadVCD":
             if (message.filePath) {
               this.loadVCDFile(message.filePath);
             }
             break;
+          case "loaded":
+            // Surfer iframe 加载完成，发送 VCD 文件
+            console.log("[VCDViewerPanel] Surfer 已加载，当前 VCD 路径:", this._currentVcdPath);
+            if (this._currentVcdPath) {
+              this.sendVcdToSurfer(this._currentVcdPath);
+            }
+            break;
         }
       },
       null,
@@ -40,8 +106,9 @@ export class VCDViewerPanel {
   /**
    * 创建或显示 VCD 查看器面板
    */
-  public static createOrShow(extensionUri: vscode.Uri, vcdFilePath?: string) {
+  public static createOrShow(extensionUri: vscode.Uri, vcdFilePath?: string, vcdFileServer?: VCDFileServer) {
-    const column = vscode.ViewColumn.One;
+    // 在当前活动编辑器旁边打开新列
+    const column = vscode.ViewColumn.Beside;
 
     // 如果已经有面板打开，则显示它
     if (VCDViewerPanel.currentPanel) {
@@ -64,7 +131,7 @@ export class VCDViewerPanel {
       }
     );
 
-    VCDViewerPanel.currentPanel = new VCDViewerPanel(panel, extensionUri);
+    VCDViewerPanel.currentPanel = new VCDViewerPanel(panel, extensionUri, vcdFileServer);
 
     // 如果提供了 VCD 文件路径，加载它
     if (vcdFilePath) {
@@ -72,23 +139,44 @@ export class VCDViewerPanel {
     }
   }
 
+  /**
+   * 从已有的 webview panel 创建 VCD 查看器（用于自定义编辑器）
+   */
+  public static createFromWebviewPanel(
+    panel: vscode.WebviewPanel,
+    extensionUri: vscode.Uri,
+    vcdFilePath: string,
+    vcdFileServer?: VCDFileServer
+  ) {
+    const viewer = new VCDViewerPanel(panel, extensionUri, vcdFileServer);
+    viewer.loadVCDFile(vcdFilePath);
+    return viewer;
+  }
+
   /**
    * 加载 VCD 文件
    */
   public loadVCDFile(vcdFilePath: string) {
     try {
+      console.log("[VCDViewerPanel] 开始加载 VCD 文件:", vcdFilePath);
+
       // 检查文件是否存在
       if (!fs.existsSync(vcdFilePath)) {
         vscode.window.showErrorMessage(`VCD 文件不存在: ${vcdFilePath}`);
         return;
       }
 
+      // 保存当前 VCD 路径
+      this._currentVcdPath = vcdFilePath;
+      console.log("[VCDViewerPanel] VCD 路径已保存:", this._currentVcdPath);
+
       // 更新面板标题
       const fileName = path.basename(vcdFilePath);
-      this._panel.title = `VCD 波形查看器 - ${fileName}`;
+      this._panel.title = `Surfer 波形查看器 - ${fileName}`;
 
       // 设置 HTML 内容
-      this._panel.webview.html = this._getWebviewContent(vcdFilePath);
+      this._panel.webview.html = this._getWebviewContent();
+      console.log("[VCDViewerPanel] Webview HTML 已设置");
     } catch (error) {
       vscode.window.showErrorMessage(
         `加载 VCD 文件失败: ${error instanceof Error ? error.message : "未知错误"}`
@@ -96,6 +184,104 @@ export class VCDViewerPanel {
     }
   }
 
+  /**
+   * 解析 VCD 文件获取根模块及其直接子模块名称
+   */
+  private parseVcdRootScope(vcdFilePath: string): string[] {
+    try {
+      // 读取 VCD 文件
+      const buffer = fs.readFileSync(vcdFilePath, { encoding: 'utf8' });
+      const lines = buffer.split('\n');
+
+      const scopeNames: string[] = [];
+      let scopeDepth = 0;
+      const scopeStack: string[] = [];
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        // 遇到 $enddefinitions 就停止解析
+        if (trimmed.startsWith('$enddefinitions')) {
+          break;
+        }
+
+        // 查找 $scope 定义
+        const scopeMatch = trimmed.match(/^\$scope\s+(\w+)\s+(\w+)/);
+        if (scopeMatch) {
+          const scopeType = scopeMatch[1];
+          const scopeName = scopeMatch[2];
+
+          // 记录顶层 module (depth = 0)
+          if (scopeDepth === 0 && scopeType === 'module') {
+            scopeStack.push(scopeName);
+            console.log("[VCDViewerPanel] 找到顶层作用域:", scopeName);
+          }
+          // 记录顶层下的直接子模块 (depth = 1)
+          else if (scopeDepth === 1 && scopeType === 'module') {
+            const fullPath = [...scopeStack, scopeName];
+            scopeNames.push(fullPath.join('.'));
+            console.log("[VCDViewerPanel] 找到子模块:", fullPath.join('.'));
+          }
+
+          scopeDepth++;
+        }
+
+        // 遇到 $upscope 减少深度
+        if (trimmed.startsWith('$upscope')) {
+          scopeDepth--;
+          if (scopeDepth === 0) {
+            scopeStack.pop();
+          }
+        }
+      }
+
+      return scopeNames;
+    } catch (error) {
+      console.error("[VCDViewerPanel] 解析 VCD 文件失败:", error);
+      return [];
+    }
+  }
+
+  /**
+   * 发送 VCD 文件到 Surfer
+   */
+  private sendVcdToSurfer(vcdFilePath: string) {
+    try {
+      console.log("[VCDViewerPanel] 准备发送 VCD 到 Surfer:", vcdFilePath);
+
+      if (!this._vcdFileServer) {
+        throw new Error("VCD 文件服务器未初始化");
+      }
+
+      // 解析 VCD 文件获取根模块名称
+      const scopeNames = this.parseVcdRootScope(vcdFilePath);
+      console.log("[VCDViewerPanel] 解析到的作用域名称:", scopeNames);
+
+      // 注册文件到 HTTP 服务器
+      const fileId = this._vcdFileServer.registerFile(vcdFilePath);
+      const httpUrl = this._vcdFileServer.getFileUrl(fileId);
+      const fileName = path.basename(vcdFilePath);
+
+      console.log("[VCDViewerPanel] 文件名:", fileName);
+      console.log("[VCDViewerPanel] HTTP URL:", httpUrl);
+
+      // 使用 LoadUrl 命令通过 HTTP 加载文件
+      this._panel.webview.postMessage({
+        command: "loadVcdUrl",
+        url: httpUrl,
+        fileName: fileName,
+        scopeNames: scopeNames, // 传递解析到的作用域名称
+      });
+
+      console.log("[VCDViewerPanel] 已发送 loadVcdUrl 消息到 webview");
+    } catch (error) {
+      console.error("[VCDViewerPanel] 发送 VCD 数据失败:", error);
+      vscode.window.showErrorMessage(
+        `发送 VCD 数据失败: ${error instanceof Error ? error.message : "未知错误"}`
+      );
+    }
+  }
+
   /**
    * 清理资源
    */
@@ -163,188 +349,239 @@ export class VCDViewerPanel {
   /**
    * 获取 Webview 的 HTML 内容
    */
-  private _getWebviewContent(vcdFilePath: string): string {
+  private _getWebviewContent(): string {
-    // 获取资源 URI
+    // 获取 surfer 资源 URI
-    const vcdromJsUri = this._panel.webview.asWebviewUri(
+    const surferJsUri = this._panel.webview.asWebviewUri(
-      vscode.Uri.joinPath(this._extensionUri, "media", "vcdrom", "vcdrom.js")
+      vscode.Uri.joinPath(this._extensionUri, "media", "surfer", "surfer.js")
     );
-    const vcdWasmUri = this._panel.webview.asWebviewUri(
+    const surferWasmUri = this._panel.webview.asWebviewUri(
-      vscode.Uri.joinPath(this._extensionUri, "media", "vcdrom", "vcd.wasm")
+      vscode.Uri.joinPath(this._extensionUri, "media", "surfer", "surfer_bg.wasm")
     );
-    const fontRegularUri = this._panel.webview.asWebviewUri(
+    const integrationJsUri = this._panel.webview.asWebviewUri(
-      vscode.Uri.joinPath(this._extensionUri, "media", "vcdrom", "IosevkaDrom-Regular.woff2")
+      vscode.Uri.joinPath(this._extensionUri, "media", "surfer", "integration.js")
     );
-    const fontObliqueUri = this._panel.webview.asWebviewUri(
-      vscode.Uri.joinPath(this._extensionUri, "media", "vcdrom", "IosevkaDrom-Oblique.woff2")
-    );
-    const fontItalicUri = this._panel.webview.asWebviewUri(
-      vscode.Uri.joinPath(this._extensionUri, "media", "vcdrom", "IosevkaDrom-Italic.woff2")
-    );
-
-    // 读取 VCD 文件内容并转换为 base64
-    const vcdContent = fs.readFileSync(vcdFilePath, "utf-8");
-    const vcdBase64 = Buffer.from(vcdContent).toString("base64");
 
     return `<!DOCTYPE html>
-<html lang="zh-CN">
+<html>
 <head>
     <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
-    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; font-src ${this._panel.webview.cspSource}; style-src 'unsafe-inline' ${this._panel.webview.cspSource}; script-src 'unsafe-inline' 'unsafe-eval' ${this._panel.webview.cspSource}; img-src ${this._panel.webview.cspSource} data:; connect-src ${this._panel.webview.cspSource};">
+    <meta http-equiv="Content-Security-Policy" content="default-src 'none'; style-src 'unsafe-inline'; script-src 'unsafe-inline' 'unsafe-eval' ${this._panel.webview.cspSource}; worker-src blob:; connect-src ${this._panel.webview.cspSource} blob: http://127.0.0.1:*;">
-    <title>VCD 波形查看器</title>
+    <title>Surfer 波形查看器</title>
+
+    <script>
+        // 获取 VS Code API（只能调用一次）
+        const vscode = acquireVsCodeApi();
+        window.vscode = vscode;
+        window.surferReady = false;
+        window.pendingVcdData = null;
+
+        function on_surfer_error(msg) {
+            console.log("Surfer error:", msg);
+            document.getElementById("error_message").innerHTML = msg;
+            document.getElementById("error_container").style.display = "block";
+        }
+        window.on_surfer_error = on_surfer_error;
+
+        // 加载 VCD URL 的函数
+        function loadVcdUrl(data) {
+            try {
+                console.log('[Webview] ========== 开始加载 VCD URL ==========');
+                console.log('[Webview] URL:', data.url);
+                console.log('[Webview] Scope names from VCD:', data.scopeNames);
+
+                // 使用 setTimeout 确保 Surfer 完全准备好
+                setTimeout(() => {
+                    console.log('[Webview] 通过 postMessage 发送 LoadUrl 命令');
+
+                    // 使用 integration.js 提供的标准 LoadUrl 命令
+                    window.postMessage({
+                        command: 'LoadUrl',
+                        url: data.url
+                    }, '*');
+
+                    console.log('[Webview] ✅ 已发送 LoadUrl 命令');
+
+                    // 等待文件加载完成后，自动添加所有信号
+                    setTimeout(async () => {
+                        try {
+                            console.log('[Webview] Attempting to add all signals automatically');
+
+                            // 使用从 VCD 文件解析出来的作用域名称
+                            let scopeNamesToTry = [];
+
+                            if (data.scopeNames && data.scopeNames.length > 0) {
+                                // 使用解析出来的实际子模块路径（例如 "tb.dut"）
+                                scopeNamesToTry = data.scopeNames.map(path => path.split('.'));
+                                console.log('[Webview] Using parsed scope names:', scopeNamesToTry);
+                            } else {
+                                // 回退到常见的根作用域名称
+                                scopeNamesToTry = [
+                                    ['top'],
+                                    ['testbench'],
+                                    ['tb'],
+                                    ['test'],
+                                    ['dut']
+                                ];
+                                console.log('[Webview] Using fallback scope names');
+                            }
+
+                            for (let i = 0; i < scopeNamesToTry.length; i++) {
+                                const scopeName = scopeNamesToTry[i];
+                                try {
+                                    const addScopeMsg = {
+                                        "AddScope": [
+                                            {
+                                                "strs": scopeName,
+                                                "id": {"Wellen": i + 1}
+                                            },
+                                            true  // 递归添加子模块的所有信号
+                                        ]
+                                    };
+                                    window.inject_message(JSON.stringify(addScopeMsg));
+                                    console.log('[Webview] Sent AddScope for: ' + scopeName.join('.') + ' (recursive)');
+                                } catch (e) {
+                                    console.log('[Webview] Failed for scope: ' + scopeName.join('.'), e);
+                                }
+                            }
+
+                            // 等待信号加载完成后，自动缩放到全部时间范围
+                            setTimeout(() => {
+                                try {
+                                    window.inject_message(JSON.stringify("ZoomToFit"));
+                                    console.log('[Webview] Sent ZoomToFit command');
+                                } catch (e) {
+                                    console.log('[Webview] ZoomToFit failed:', e);
+                                }
+                            }, 500);
+
+                        } catch (e) {
+                            console.error('[Webview] Failed to add signals:', e);
+                        }
+                    }, 1500);
+
+                }, 100);
+
+            } catch (error) {
+                console.error('[Webview] ❌ 加载 VCD 失败:', error);
+                on_surfer_error(error.message + '\\n' + error.stack);
+            }
+        }
+        window.loadVcdUrl = loadVcdUrl;
+    </script>
+
+    <script type="module">
+        console.log('[Webview] 开始初始化 Surfer...');
+        import init from '${surferJsUri}';
+        await init({module_or_path: '${surferWasmUri}'});
+        console.log('[Webview] Surfer WASM 已加载');
+
+        import {WebHandle, inject_message, id_of_name, draw_text_arrow} from '${surferJsUri}';
+        window.inject_message = inject_message;
+        window.id_of_name = id_of_name;
+        window.draw_text_arrow = draw_text_arrow;
+
+        console.log('[Webview] Surfer 函数已导入，inject_message 类型:', typeof window.inject_message);
+
+        // 等待一小段时间确保 Surfer 完全初始化
+        await new Promise(resolve => setTimeout(resolve, 100));
+
+        window.surferReady = true;
+        console.log('[Webview] Surfer 已完全初始化并准备就绪');
+
+        // 关闭 Surfer 的日志面板（如果打开的话）
+        try {
+            window.inject_message(JSON.stringify("ToggleLogs"));
+            console.log('[Webview] 已发送关闭日志面板命令');
+        } catch (e) {
+            console.log('[Webview] 关闭日志面板失败:', e);
+        }
+
+        // 如果有待处理的 VCD 数据，现在加载它
+        if (window.pendingVcdData) {
+            console.log('[Webview] 发现待处理的 VCD 数据，立即加载');
+            loadVcdUrl(window.pendingVcdData);
+            window.pendingVcdData = null;
+        } else {
+            console.log('[Webview] 没有待处理的 VCD 数据');
+        }
+
+        // 通知 VS Code surfer 已加载完成
+        console.log('[Webview] 发送 loaded 消息到 VS Code');
+        window.vscode.postMessage({ command: 'loaded' });
+    </script>
+
     <style>
-        @font-face {
+        html, body {
-            font-family: 'Iosevka Drom Web';
-            font-display: swap;
-            font-weight: 400;
-            font-stretch: normal;
-            font-style: normal;
-            src: url('${fontRegularUri}') format('woff2');
-        }
-
-        @font-face {
-            font-family: 'Iosevka Drom Web';
-            font-display: swap;
-            font-weight: 400;
-            font-stretch: normal;
-            font-style: oblique;
-            src: url('${fontObliqueUri}') format('woff2');
-        }
-
-        @font-face {
-            font-family: 'Iosevka Drom Web';
-            font-display: swap;
-            font-weight: 400;
-            font-stretch: normal;
-            font-style: italic;
-            src: url('${fontItalicUri}') format('woff2');
-        }
-
-        * {
-            margin: 0;
-            padding: 0;
-            box-sizing: border-box;
-        }
-
-        body {
-            font-family: 'Iosevka Drom Web', monospace;
-            color: var(--vscode-foreground);
-            background-color: var(--vscode-editor-background);
             overflow: hidden;
+            margin: 0 !important;
+            padding: 0 !important;
+            height: 100%;
+            width: 100%;
+            background: var(--vscode-editor-background);
         }
 
-        #waveform-container {
+        canvas {
-            width: 100vw;
+            margin-right: auto;
-            height: 100vh;
+            margin-left: auto;
-            overflow: auto;
+            display: block;
-        }
+            position: absolute;
-
+            top: 0;
-        #waveform1 {
+            left: 0;
             width: 100%;
             height: 100%;
         }
 
-        .loading {
+        #error_container {
-            display: flex;
+            padding: 1em;
-            justify-content: center;
+            border-radius: 0.5em;
-            align-items: center;
+            margin: 0px auto;
-            height: 100vh;
+            max-width: 980px;
-            flex-direction: column;
-        }
-
-        .spinner {
-            border: 4px solid var(--vscode-progressBar-background);
-            border-top: 4px solid var(--vscode-progressBar-foreground);
-            border-radius: 50%;
-            width: 40px;
-            height: 40px;
-            animation: spin 1s linear infinite;
-            margin-bottom: 20px;
-        }
-
-        @keyframes spin {
-            0% { transform: rotate(0deg); }
-            100% { transform: rotate(360deg); }
-        }
-
-        .error-message {
-            padding: 20px;
             color: var(--vscode-errorForeground);
             background-color: var(--vscode-inputValidation-errorBackground);
-            border: 1px solid var(--vscode-inputValidation-errorBorder);
+            position: relative;
-            border-radius: 4px;
+            height: 90%;
-            margin: 20px;
+            overflow: scroll;
+        }
+
+        #error_message {
+            overflow: scroll;
+            white-space: break-spaces;
         }
     </style>
-    <script src="${vcdromJsUri}"></script>
 </head>
 <body>
-    <div id="waveform-container">
+    <canvas id="the_canvas_id"></canvas>
-        <div class="loading">
+
-            <div class="spinner"></div>
+    <div id="error_container" style="display: none;">
-            <p>正在加载 VCD 波形...</p>
+        <h3>❌ Surfer 加载失败</h3>
-        </div>
+        <code id="error_message"></code>
-        <div id="waveform1"></div>
     </div>
 
+    <script src="${integrationJsUri}"></script>
     <script>
-        (async function() {
+        register_message_listener();
-            try {
-                // 设置 WASM 文件路径
-                window.wasmBinaryFile = '${vcdWasmUri}';
 
-                // 解码 base64 VCD 内容
+        console.log('[Webview] 注册 VS Code 消息监听器');
-                const vcdBase64 = '${vcdBase64}';
+        // 监听来自 VS Code 扩展的消息（使用 vscode API）
-                const vcdContent = atob(vcdBase64);
+        window.addEventListener('message', event => {
+            const message = event.data;
 
-                // 隐藏加载提示
+            // 检查是否来自 VS Code
-                document.querySelector('.loading').style.display = 'none';
+            if (message.command === 'loadVcdUrl') {
+                console.log('[Webview] 收到 VS Code 消息，命令:', message.command);
+                console.log('[Webview] Surfer 就绪状态:', window.surferReady);
 
-                // 创建一个函数来提供 VCD 数据流
+                if (window.surferReady) {
-                const vcdProvider = async (handler) => {
+                    // Surfer 已就绪，立即加载
-                    // 将 VCD 内容转换为 Uint8Array
+                    loadVcdUrl(message);
-                    const encoder = new TextEncoder();
-                    const vcdData = encoder.encode(vcdContent);
-
-                    // 创建一个 ReadableStream reader
-                    const stream = new ReadableStream({
-                        start(controller) {
-                            controller.enqueue(vcdData);
-                            controller.close();
-                        }
-                    });
-
-                    const reader = stream.getReader();
-
-                    // 调用 handler 并传递 reader
-                    await handler([{
-                        key: 'local',
-                        value: 'waveform.vcd',
-                        format: 'raw',
-                        baseName: 'waveform.vcd',
-                        ext: 'vcd',
-                        reader: reader
-                    }]);
-                };
-
-                // 初始化 VCDrom，使用函数回调方式
-                if (typeof VCDrom === 'function') {
-                    await VCDrom('waveform1', vcdProvider);
                 } else {
-                    throw new Error('VCDrom 未正确加载');
+                    // Surfer 未就绪，保存数据等待加载
+                    console.log('[Webview] Surfer 未就绪，保存数据待加载');
+                    window.pendingVcdData = message;
                 }
-
-            } catch (error) {
-                console.error('加载 VCD 波形失败:', error);
-                document.getElementById('waveform-container').innerHTML =
-                    '<div class="error-message">' +
-                    '<h3>❌ 加载 VCD 波形失败</h3>' +
-                    '<p>' + error.message + '</p>' +
-                    '<p style="margin-top: 10px;">请确保 VCD 文件格式正确。</p>' +
-                    '<pre style="margin-top: 10px; padding: 10px; background: rgba(0,0,0,0.1); overflow: auto;">' + error.stack + '</pre>' +
-                    '</div>';
             }
-        })();
+        }, true); // 使用捕获阶段，优先于 integration.js 的监听器
     </script>
 </body>
 </html>`;

src/services/apiClient.ts

@@ -0,0 +1,226 @@
+/**
+ * API 客户端
+ * 封装与后端的 HTTP 通信
+ */
+import * as https from 'https';
+import * as http from 'http';
+import { URL } from 'url';
+import { getApiUrl, getConfig } from '../config/settings';
+import type { ToolCallResult, AnswerRequest, ToolResultResponse, AnswerResponse, ToolConfirmResponse, UserInfoResponse } from '../types/api';
+
+/**
+ * HTTP 请求选项
+ */
+interface RequestOptions {
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  headers?: Record<string, string>;
+  body?: unknown;
+  timeout?: number;
+}
+
+/**
+ * 发送 HTTP 请求
+ */
+async function request<T>(path: string, options: RequestOptions): Promise<T> {
+  const url = new URL(getApiUrl(path));
+  const { timeout } = getConfig();
+
+  const isHttps = url.protocol === 'https:';
+  const httpModule = isHttps ? https : http;
+
+  const requestOptions: http.RequestOptions = {
+    hostname: url.hostname,
+    port: url.port || (isHttps ? 443 : 80),
+    path: url.pathname + url.search,
+    method: options.method,
+    headers: {
+      'Content-Type': 'application/json',
+      ...options.headers
+    },
+    timeout: options.timeout || timeout
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = httpModule.request(requestOptions, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json as T);
+          } else {
+            reject(new Error(json.error || json.message || `HTTP ${res.statusCode}`));
+          }
+        } catch (e) {
+          reject(new Error(`解析响应失败: ${data}`));
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('请求超时'));
+    });
+
+    if (options.body) {
+      req.write(JSON.stringify(options.body));
+    }
+
+    req.end();
+  });
+}
+
+/**
+ * 提交工具执行结果
+ * POST /api/tool/result
+ */
+export async function submitToolResult(result: ToolCallResult): Promise<ToolResultResponse> {
+  console.log(`[API] 提交工具结果: callId=${result.id}`);
+  return request<ToolResultResponse>('/api/tool/result', {
+    method: 'POST',
+    body: result
+  });
+}
+
+/**
+ * 提交用户回答
+ * POST /api/task/answer
+ */
+export async function submitAnswer(answer: AnswerRequest): Promise<AnswerResponse> {
+  console.log(`[API] 提交用户回答: askId=${answer.askId}`);
+  return request<AnswerResponse>('/api/task/answer', {
+    method: 'POST',
+    body: answer
+  });
+}
+
+/**
+ * 提交工具确认响应（Ask 模式）
+ * POST /api/tool/confirm
+ */
+export async function submitToolConfirm(response: ToolConfirmResponse): Promise<ToolResultResponse> {
+  console.log(`[API] 提交工具确认: confirmId=${response.confirmId}, approved=${response.approved}`);
+  return request<ToolResultResponse>('/api/tool/confirm', {
+    method: 'POST',
+    body: response
+  });
+}
+
+/**
+ * 健康检查
+ * GET /api/dialog/health
+ */
+export async function healthCheck(): Promise<{ status: string }> {
+  return request<{ status: string }>('/api/dialog/health', {
+    method: 'GET',
+    timeout: 5000
+  });
+}
+
+/**
+ * 停止对话请求
+ */
+export interface StopDialogRequest {
+  taskId: string;
+}
+
+/**
+ * 停止对话响应
+ */
+export interface StopDialogResponse {
+  success: boolean;
+  taskId: string;
+  message?: string;
+  error?: string;
+}
+
+/**
+ * 停止对话
+ * POST /api/dialog/stop
+ */
+export async function stopDialog(taskId: string): Promise<StopDialogResponse> {
+  console.log(`[API] 停止对话: taskId=${taskId}`);
+  return request<StopDialogResponse>('/api/dialog/stop', {
+    method: 'POST',
+    body: { taskId }
+  });
+}
+
+/** 压缩对话响应 */
+export interface CompactDialogResponse {
+  success: boolean;
+  taskId: string;
+  message?: string;
+  error?: string;
+}
+
+/**
+ * 手动压缩对话历史
+ * POST /api/dialog/compact
+ */
+export async function compactDialog(taskId: string): Promise<CompactDialogResponse> {
+  console.log(`[API] 压缩对话: taskId=${taskId}`);
+  return request<CompactDialogResponse>('/api/dialog/compact', {
+    method: 'POST',
+    body: { taskId }
+  });
+}
+
+/**
+ * 创建成功的工具结果
+ */
+export function createSuccessResult(id: number, text: string): ToolCallResult {
+  return {
+    jsonrpc: '2.0',
+    id,
+    result: {
+      content: [{ type: 'text', text }],
+      isError: false
+    }
+  };
+}
+
+/**
+ * 创建业务错误的工具结果（如编译失败）
+ */
+export function createBusinessErrorResult(id: number, errorMessage: string): ToolCallResult {
+  return {
+    jsonrpc: '2.0',
+    id,
+    result: {
+      content: [{ type: 'text', text: errorMessage }],
+      isError: true
+    }
+  };
+}
+
+/**
+ * 创建系统错误的工具结果
+ */
+export function createSystemErrorResult(id: number, code: number, message: string): ToolCallResult {
+  return {
+    jsonrpc: '2.0',
+    id,
+    error: { code, message }
+  };
+}
+
+/**
+ * 获取用户信息
+ * GET /system/user/getInfo
+ */
+export async function getUserInfo(): Promise<UserInfoResponse> {
+  console.log('[API] 获取用户信息');
+  return request<UserInfoResponse>('/system/user/getInfo', {
+    method: 'GET'
+  });
+}

src/services/dialogService.ts

@@ -0,0 +1,755 @@
+/**
+ * 对话服务
+ * 整合 SSE 通信、工具执行、用户交互
+ */
+import * as vscode from 'vscode';
+import * as fs from 'fs';
+import * as path from 'path';
+import { startStreamDialog, generateTaskId, SSEController, SSECallbacks } from './sseHandler';
+import { executeToolCall, createToolExecutorContext, ToolExecutorContext } from './toolExecutor';
+import { userInteractionManager } from './userInteraction';
+import { getConfig } from '../config/settings';
+import type { DialogRequest, ToolCallRequest, AskUserEvent, RunMode, ServiceTier, ToolConfirmEvent, PlanConfirmEvent } from '../types/api';
+import { submitToolConfirm, submitAnswer, stopDialog } from './apiClient';
+import { ChatHistoryManager } from '../utils/chatHistoryManager';
+
+/**
+ * 消息段落类型
+ */
+export interface MessageSegment {
+  type: 'text' | 'tool' | 'question' | 'agent' | 'plan';
+  content?: string;
+  toolName?: string;
+  toolStatus?: 'running' | 'success' | 'error';
+  toolResult?: string;
+  askId?: string;
+  question?: string;
+  options?: string[];
+  // 智能体相关字段
+  agentId?: string;
+  agentName?: string;
+  agentStatus?: 'running' | 'completed' | 'error';
+  agentSteps?: AgentStep[];
+  // 计划相关字段
+  planTitle?: string;
+  planSteps?: string[];
+  planSummary?: string;
+}
+
+/**
+ * 智能体执行步骤
+ */
+export interface AgentStep {
+  step: number;
+  toolName: string;
+  toolInput?: unknown;
+  toolResult?: string;
+  status: 'running' | 'completed' | 'error';
+}
+
+/**
+ * 对话回调接口
+ */
+export interface DialogCallbacks {
+  /** 收到文本（可能多次调用，流式） */
+  onText?: (text: string, isStreaming: boolean) => void;
+  /** 工具开始执行 */
+  onToolStart?: (toolName: string) => void;
+  /** 工具执行完成 */
+  onToolComplete?: (toolName: string, result: string) => void;
+  /** 工具执行错误 */
+  onToolError?: (toolName: string, error: string) => void;
+  /** 工具确认请求（Ask 模式） */
+  onToolConfirm?: (confirmId: number, toolName: string, toolInput: Record<string, unknown>) => void;
+  /** 计划确认请求（Plan 模式） */
+  onPlanConfirm?: (confirmId: number, title: string, steps: string[], summary: string) => void;
+  /** 显示问题（ask_user） */
+  onQuestion?: (askId: string, question: string, options: string[]) => void;
+  /** 实时更新段落（流式过程中） */
+  onSegmentUpdate?: (segments: MessageSegment[]) => void;
+  /** 对话完成，返回所有段落 */
+  onComplete?: (segments: MessageSegment[]) => void;
+  /** 错误 */
+  onError?: (message: string) => void;
+  /** 通知消息 */
+  onNotification?: (message: string) => void;
+  /** 上下文使用量更新 */
+  onContextUsage?: (data: { currentTokens: number; maxTokens: number; percentage: number }) => void;
+}
+
+/**
+ * 对话会话
+ */
+export class DialogSession {
+  private taskId: string;
+  private sseController: SSEController | null = null;
+  private toolContext: ToolExecutorContext;
+  private accumulatedText = '';
+  private isActive = false;
+  private segments: MessageSegment[] = [];
+  private currentTextSegment: MessageSegment | null = null;
+
+  constructor(extensionPath: string, existingTaskId?: string) {
+    // 支持复用现有 taskId（用于 Plan 模式确认后继续执行）
+    this.taskId = existingTaskId || generateTaskId();
+    this.toolContext = createToolExecutorContext(extensionPath);
+  }
+
+  /**
+   * 添加文本到当前文本段落
+   */
+  private appendText(text: string): void {
+    if (!this.currentTextSegment) {
+      this.currentTextSegment = { type: 'text', content: '' };
+      this.segments.push(this.currentTextSegment);
+    }
+    this.currentTextSegment.content = (this.currentTextSegment.content || '') + text;
+  }
+
+  /**
+   * 结束当前文本段落
+   */
+  private finalizeTextSegment(): void {
+    this.currentTextSegment = null;
+  }
+
+  /**
+   * 添加工具段落
+   */
+  private addToolSegment(toolName: string, status: 'running' | 'success' | 'error', result?: string): MessageSegment {
+    this.finalizeTextSegment();
+    const segment: MessageSegment = {
+      type: 'tool',
+      toolName,
+      toolStatus: status,
+      toolResult: result
+    };
+    this.segments.push(segment);
+    return segment;
+  }
+
+  /**
+   * 更新工具段落状态
+   */
+  private updateToolSegment(toolName: string, status: 'success' | 'error', result?: string): void {
+    // 找到最后一个匹配的工具段落
+    for (let i = this.segments.length - 1; i >= 0; i--) {
+      const seg = this.segments[i];
+      if (seg.type === 'tool' && seg.toolName === toolName && seg.toolStatus === 'running') {
+        seg.toolStatus = status;
+        seg.toolResult = result;
+        break;
+      }
+    }
+  }
+
+  /**
+   * 获取任务ID
+   */
+  getTaskId(): string {
+    return this.taskId;
+  }
+
+  /**
+   * 是否活跃
+   */
+  get active(): boolean {
+    return this.isActive;
+  }
+
+  /**
+   * 加载知识图谱数据
+   * 从 .iccoder/knowledge.json 读取
+   */
+  private async loadKnowledgeData(): Promise<string | null> {
+    console.log('[DialogSession] loadKnowledgeData 开始执行');
+
+    // 等待 workspaceFolders 就绪（首次打开窗口/首次触发命令时可能为空）
+    const workspaceFolders = await this.waitForWorkspaceFolders();
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+      console.log('[DialogSession] 没有工作区文件夹');
+      return null;
+    }
+
+    // 多根工作区场景：优先读取实际存在 knowledge.json 的根目录
+    for (const folder of this.getWorkspaceFolderCandidates(workspaceFolders)) {
+      const knowledgeUri = vscode.Uri.joinPath(folder.uri, '.iccoder', 'knowledge.json');
+      console.log('[DialogSession] 知识图谱 URI:', knowledgeUri.toString());
+
+      try {
+        const content = await this.readTextFileWithRetry(knowledgeUri, 5);
+        if (!content) {
+          continue;
+        }
+
+        // 基础校验 + 清洗：避免偶发读取到半截内容导致后端反序列化失败
+        try {
+          const parsed = JSON.parse(content) as any;
+
+          // 兼容：后端 KnowledgeGraph.isEmpty() 可能被序列化为 "empty"，老后端反序列化会失败
+          if (parsed && typeof parsed === 'object' && 'empty' in parsed) {
+            delete parsed.empty;
+          }
+
+          const sanitized = JSON.stringify(parsed);
+          console.log('[DialogSession] 知识图谱已清洗, sanitizedLen:', sanitized.length);
+          return sanitized;
+        } catch (e) {
+          console.warn('[DialogSession] 知识图谱 JSON 解析失败，跳过本次读取:', e);
+          continue;
+        }
+      } catch (error) {
+        console.warn('[DialogSession] 加载知识图谱失败:', error);
+      }
+    }
+
+    return null;
+  }
+
+  private async waitForWorkspaceFolders(): Promise<readonly vscode.WorkspaceFolder[] | undefined> {
+    for (let i = 0; i < 10; i++) {
+      const folders = vscode.workspace.workspaceFolders;
+      if (folders && folders.length > 0) {
+        return folders;
+      }
+      await new Promise(resolve => setTimeout(resolve, 100));
+    }
+    return vscode.workspace.workspaceFolders;
+  }
+
+  private getWorkspaceFolderCandidates(
+    workspaceFolders: readonly vscode.WorkspaceFolder[]
+  ): vscode.WorkspaceFolder[] {
+    const result: vscode.WorkspaceFolder[] = [];
+
+    // 1) 当前激活文件所在的 workspace folder（如果有）
+    const activeUri = vscode.window.activeTextEditor?.document?.uri;
+    const activeFolder = activeUri ? vscode.workspace.getWorkspaceFolder(activeUri) : undefined;
+    if (activeFolder) {
+      result.push(activeFolder);
+    }
+
+    // 2) 其它 workspace folders（去重）
+    for (const folder of workspaceFolders) {
+      if (!result.some(f => f.uri.toString() === folder.uri.toString())) {
+        result.push(folder);
+      }
+    }
+
+    return result;
+  }
+
+  private async readTextFileWithRetry(uri: vscode.Uri, maxAttempts: number): Promise<string | null> {
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+      try {
+        const bytes = await vscode.workspace.fs.readFile(uri);
+        const text = Buffer.from(bytes).toString('utf-8');
+        if (!text || !text.trim()) {
+          return null;
+        }
+        return text;
+      } catch (error) {
+        // 文件不存在：不是错误，直接返回 null
+        if (error instanceof vscode.FileSystemError && error.code === 'FileNotFound') {
+          return null;
+        }
+
+        const retryable =
+          (error instanceof vscode.FileSystemError && error.code === 'Unavailable') ||
+          (typeof (error as any)?.code === 'string' && ['EBUSY', 'EPERM', 'EACCES'].includes((error as any).code));
+
+        if (!retryable || attempt >= maxAttempts) {
+          throw error;
+        }
+
+        const delayMs = 50 * attempt;
+        console.log(`[DialogSession] 读取知识图谱失败（可重试）: attempt=${attempt}/${maxAttempts}, delay=${delayMs}ms`);
+        await new Promise(resolve => setTimeout(resolve, delayMs));
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * 获取工具操作描述（用于确认对话框）
+   */
+  private getToolDescription(toolName: string, toolInput: Record<string, unknown>): string {
+    const lines: string[] = [];
+
+    switch (toolName) {
+      case 'file_write':
+        lines.push(`文件路径: ${toolInput.path || '未知'}`);
+        if (toolInput.content) {
+          const content = String(toolInput.content);
+          lines.push(`内容长度: ${content.length} 字符`);
+          lines.push(`内容预览: ${content.substring(0, 100)}${content.length > 100 ? '...' : ''}`);
+        }
+        break;
+      case 'file_delete':
+        lines.push(`删除文件: ${toolInput.path || '未知'}`);
+        break;
+      case 'syntax_check':
+        lines.push('执行语法检查');
+        if (toolInput.code) {
+          const code = String(toolInput.code);
+          lines.push(`代码长度: ${code.length} 字符`);
+        }
+        break;
+      case 'simulation':
+        lines.push(`RTL文件: ${toolInput.rtlPath || '未知'}`);
+        lines.push(`TB文件: ${toolInput.tbPath || '未知'}`);
+        if (toolInput.duration) {
+          lines.push(`仿真时长: ${toolInput.duration}`);
+        }
+        break;
+      default:
+        lines.push(`参数: ${JSON.stringify(toolInput, null, 2)}`);
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * 发送消息并开始流式对话
+   */
+  async sendMessage(
+    message: string,
+    callbacks: DialogCallbacks,
+    mode?: RunMode,
+    serviceTier?: ServiceTier  // 新增：服务等级参数
+  ): Promise<void> {
+    if (this.isActive) {
+      callbacks.onError?.('当前有对话正在进行中');
+      return;
+    }
+
+    this.isActive = true;
+    this.accumulatedText = '';
+    this.segments = [];
+    this.currentTextSegment = null;
+
+    const config = getConfig();
+
+    // 获取压缩数据和新消息（用于后端重启后恢复）
+    const historyManager = ChatHistoryManager.getInstance();
+    const compactedData = await historyManager.loadCompactedData(this.taskId);
+    const newMessages = historyManager.getNewMessagesSinceCompaction();
+
+    // 加载知识图谱数据
+    const knowledgeData = await this.loadKnowledgeData();
+    console.log('[DialogSession] knowledgeData 加载结果:', knowledgeData ? `${knowledgeData.length} 字符` : 'null');
+
+    const request: DialogRequest = {
+      taskId: this.taskId,
+      message,
+      userId: config.userId,
+      mode: mode || 'agent',
+      serviceTier: serviceTier || config.serviceTier,  // 优先使用传入的参数
+      compactedData: compactedData || undefined,
+      newMessages: newMessages.length > 0 ? newMessages : undefined,
+      knowledgeData: knowledgeData || undefined
+    };
+
+    // 追踪用户消息
+    historyManager.trackUserMessage(message);
+
+    const sseCallbacks: SSECallbacks = {
+      onTextDelta: (data) => {
+        this.accumulatedText += data.text;
+        this.appendText(data.text);
+        console.log('[DialogSession] onTextDelta, 累积文本长度:', this.accumulatedText.length);
+        callbacks.onText?.(this.accumulatedText, true);
+        // 实时发送段落更新
+        callbacks.onSegmentUpdate?.(this.segments);
+      },
+
+      onToolCall: async (data: ToolCallRequest) => {
+        const toolName = data.params.name;
+        console.log('[DialogSession] onToolCall:', toolName);
+
+        // 检查是否有活跃的智能体（如果有，工具执行会显示在智能体卡片内，不需要单独显示）
+        const hasActiveAgent = this.segments.some(
+          s => s.type === 'agent' && s.agentStatus === 'running'
+        );
+
+        if (hasActiveAgent) {
+          console.log('[DialogSession] onToolCall: 智能体执行中，跳过工具段落:', toolName);
+        } else {
+          // 检查是否已经有相同的工具段落（可能由 onToolStart 添加）
+          const lastToolSegment = this.segments.filter(s => s.type === 'tool').pop();
+          if (lastToolSegment && lastToolSegment.toolName === toolName && lastToolSegment.toolStatus === 'running') {
+            console.log('[DialogSession] onToolCall: 跳过重复的工具段落:', toolName);
+          } else {
+            this.addToolSegment(toolName, 'running');
+            // 实时发送段落更新
+            callbacks.onSegmentUpdate?.(this.segments);
+          }
+        }
+
+        // 注意：不在这里调用 callbacks.onToolStart，避免与 onToolStart 事件重复
+        try {
+          await executeToolCall(data, this.toolContext);
+          if (!hasActiveAgent) {
+            this.updateToolSegment(toolName, 'success', '执行完成');
+            // 实时发送段落更新
+            callbacks.onSegmentUpdate?.(this.segments);
+          }
+          // 也不调用 callbacks.onToolComplete，避免重复
+        } catch (error) {
+          const errorMsg = error instanceof Error ? error.message : '未知错误';
+          if (!hasActiveAgent) {
+            this.updateToolSegment(toolName, 'error', errorMsg);
+            callbacks.onSegmentUpdate?.(this.segments);
+          }
+          callbacks.onToolError?.(toolName, errorMsg);
+        }
+      },
+
+      onToolStart: (data) => {
+        console.log('[DialogSession] onToolStart:', data.tool_name);
+        // 检查是否已经有相同的工具段落（可能由 onToolCall 添加）
+        const lastToolSegment = this.segments.filter(s => s.type === 'tool').pop();
+        if (lastToolSegment && lastToolSegment.toolName === data.tool_name && lastToolSegment.toolStatus === 'running') {
+          console.log('[DialogSession] 跳过重复的工具段落:', data.tool_name);
+        } else {
+          this.addToolSegment(data.tool_name, 'running');
+          // 实时发送段落更新
+          callbacks.onSegmentUpdate?.(this.segments);
+        }
+        console.log('[DialogSession] segments 数量:', this.segments.length);
+        callbacks.onToolStart?.(data.tool_name);
+      },
+
+      onToolComplete: (data) => {
+        this.updateToolSegment(data.tool_name, 'success', data.result);
+        callbacks.onToolComplete?.(data.tool_name, data.result);
+        // 实时发送段落更新
+        callbacks.onSegmentUpdate?.(this.segments);
+      },
+
+      onToolError: (data) => {
+        this.updateToolSegment(data.tool_name, 'error', data.error);
+        callbacks.onToolError?.(data.tool_name, data.error);
+        // 实时发送段落更新
+        callbacks.onSegmentUpdate?.(this.segments);
+      },
+
+      onToolConfirm: async (data: ToolConfirmEvent) => {
+        console.log('[DialogSession] onToolConfirm:', data.toolName, data.confirmId);
+
+        // 结束当前文本段落
+        this.finalizeTextSegment();
+
+        // 生成工具描述
+        const toolDescription = this.getToolDescription(data.toolName, data.toolInput);
+
+        // 构建问题文本
+        const toolNameMap: Record<string, string> = {
+          'file_write': '写入文件',
+          'file_delete': '删除文件',
+          'syntax_check': '语法检查',
+          'simulation': '运行仿真'
+        };
+        const toolDisplayName = toolNameMap[data.toolName] || data.toolName;
+        const question = `确认执行操作：${toolDisplayName}\n\n${toolDescription}`;
+
+        // 生成唯一的 askId
+        const askId = `tool_confirm_${data.confirmId}`;
+
+        // 添加问题段落到聊天界面
+        this.segments.push({
+          type: 'question',
+          askId: askId,
+          question: question,
+          options: ['确认执行', '取消']
+        });
+
+        // 实时发送段落更新
+        callbacks.onSegmentUpdate?.(this.segments);
+
+        // 调用回调通知 UI
+        callbacks.onToolConfirm?.(data.confirmId, data.toolName, data.toolInput);
+
+        // 使用 userInteractionManager 等待用户回答
+        try {
+          await userInteractionManager.handleAskUser(
+            {
+              askId: askId,
+              question: question,
+              options: ['确认执行', '取消']
+            } as AskUserEvent,
+            this.taskId
+          );
+
+          // 注意：用户回答后，需要在 receiveAnswer 中处理 tool_confirm 类型的 askId
+          // 这里不直接调用 submitToolConfirm，而是在 userInteractionManager 中统一处理
+        } catch (error) {
+          console.error('[DialogSession] 处理工具确认失败:', error);
+          // 如果出错，默认取消执行
+          try {
+            await submitToolConfirm({
+              confirmId: data.confirmId,
+              taskId: this.taskId,
+              approved: false
+            });
+          } catch (submitError) {
+            console.error('[DialogSession] 发送取消响应失败:', submitError);
+          }
+        }
+      },
+
+      onPlanConfirm: async (data: PlanConfirmEvent) => {
+        console.log('[DialogSession] onPlanConfirm:', data.title);
+
+        // 结束当前文本段落
+        this.finalizeTextSegment();
+
+        const askId = `ask_${data.confirmId}`;
+
+        // 添加计划段落到聊天界面（包含 askId 用于响应）
+        this.segments.push({
+          type: 'plan',
+          askId: askId,
+          planTitle: data.title,
+          planSteps: data.steps,
+          planSummary: data.summary
+        });
+
+        // 实时发送段落更新
+        callbacks.onSegmentUpdate?.(this.segments);
+
+        // 注册问题到前端（类似 askUser），以便用户回答时能找到
+        const planEvent = {
+          askId: askId,
+          question: `请确认执行计划：${data.title}`,
+          options: ['确认执行', '修改计划', '取消']
+        };
+        try {
+          await userInteractionManager.handleAskUser(planEvent as AskUserEvent, this.taskId);
+        } catch (error) {
+          console.error('[DialogSession] 处理计划确认失败:', error);
+        }
+
+        // 调用回调通知 UI
+        callbacks.onPlanConfirm?.(data.confirmId, data.title, data.steps, data.summary);
+      },
+
+      onAskUser: async (data: AskUserEvent) => {
+        this.finalizeTextSegment();
+        this.segments.push({
+          type: 'question',
+          askId: data.askId,
+          question: data.question,
+          options: data.options
+        });
+        // 实时发送段落更新（包含问题）
+        callbacks.onSegmentUpdate?.(this.segments);
+        // 同时调用 onQuestion 用于更新状态栏等
+        callbacks.onQuestion?.(data.askId, data.question, data.options);
+        try {
+          await userInteractionManager.handleAskUser(data, this.taskId);
+        } catch (error) {
+          console.error('[DialogSession] 处理用户问题失败:', error);
+        }
+      },
+
+      onComplete: (data) => {
+        this.isActive = false;
+        this.finalizeTextSegment();
+
+        // 追踪 AI 消息（用于后端重启后恢复）
+        if (this.accumulatedText) {
+          historyManager.trackAiMessage(this.accumulatedText);
+        }
+
+        // 发送所有段落
+        callbacks.onComplete?.(this.segments);
+      },
+
+      onError: (data) => {
+        this.isActive = false;
+        callbacks.onError?.(data.message);
+      },
+
+      onWarning: (data) => {
+        callbacks.onNotification?.(`⚠️ ${data.message}`);
+      },
+
+      onNotification: (data) => {
+        callbacks.onNotification?.(data.message);
+      },
+
+      // 智能体事件处理
+      onAgentStart: (data) => {
+        console.log('[DialogSession] onAgentStart:', data.agentId);
+        this.finalizeTextSegment();
+        this.segments.push({
+          type: 'agent',
+          agentId: data.agentId,
+          agentName: data.agentName,
+          content: data.instruction,
+          agentStatus: 'running',
+          agentSteps: []
+        });
+        callbacks.onSegmentUpdate?.(this.segments);
+      },
+
+      onAgentProgress: (data) => {
+        console.log('[DialogSession] onAgentProgress:', data.agentId, data.step, data.status);
+        const agentSegment = this.segments.find(
+          s => s.type === 'agent' && s.agentId === data.agentId
+        );
+        if (agentSegment && agentSegment.agentSteps) {
+          if (data.status === 'running') {
+            agentSegment.agentSteps.push({
+              step: data.step,
+              toolName: data.toolName,
+              toolInput: data.toolInput,
+              status: 'running'
+            });
+          } else {
+            const step = agentSegment.agentSteps.find(s => s.step === data.step);
+            if (step) {
+              step.status = data.status;
+              step.toolResult = data.toolResult;
+            }
+          }
+          callbacks.onSegmentUpdate?.(this.segments);
+        }
+      },
+
+      onAgentComplete: (data) => {
+        console.log('[DialogSession] onAgentComplete:', data.agentId);
+        const agentSegment = this.segments.find(
+          s => s.type === 'agent' && s.agentId === data.agentId
+        );
+        if (agentSegment) {
+          agentSegment.agentStatus = 'completed';
+          agentSegment.content = data.summary;
+          callbacks.onSegmentUpdate?.(this.segments);
+        }
+      },
+
+      onAgentError: (data) => {
+        console.log('[DialogSession] onAgentError:', data.agentId, data.error);
+        const agentSegment = this.segments.find(
+          s => s.type === 'agent' && s.agentId === data.agentId
+        );
+        if (agentSegment) {
+          agentSegment.agentStatus = 'error';
+          agentSegment.content = data.error;
+          callbacks.onSegmentUpdate?.(this.segments);
+        }
+      },
+
+      onMemoryCompacted: async (data) => {
+        console.log('[DialogSession] onMemoryCompacted:', data.taskId);
+        // 保存压缩数据到本地
+        await historyManager.saveCompactedData(data.compactedData);
+      },
+
+      onContextUsage: (data) => {
+        console.log('[DialogSession] onContextUsage:', data.currentTokens, '/', data.maxTokens);
+        callbacks.onContextUsage?.(data);
+      },
+
+      onOpen: () => {
+        console.log('[DialogSession] SSE 连接已建立');
+      },
+
+      onClose: () => {
+        console.log('[DialogSession] SSE 连接已关闭');
+        this.isActive = false;
+      }
+    };
+
+    try {
+      this.sseController = await startStreamDialog(request, sseCallbacks);
+    } catch (error) {
+      this.isActive = false;
+      const errorMsg = error instanceof Error ? error.message : '连接失败';
+      callbacks.onError?.(errorMsg);
+      throw error;
+    }
+  }
+
+  /**
+   * 中止当前对话
+   */
+  abort(): void {
+    if (this.sseController) {
+      this.sseController.abort();
+      this.sseController = null;
+    }
+    this.isActive = false;
+    userInteractionManager.cancelAll();
+
+    // 通知后端停止处理
+    stopDialog(this.taskId).catch(err => {
+      console.warn('[DialogSession] 停止对话请求失败:', err);
+    });
+  }
+
+  /**
+   * 获取当前的消息段落（用于中止时保存）
+   */
+  getSegments(): MessageSegment[] {
+    return this.segments;
+  }
+
+  /**
+   * 获取累积的文本内容
+   */
+  getAccumulatedText(): string {
+    return this.accumulatedText;
+  }
+
+  /**
+   * 提交用户回答
+   */
+  async submitAnswer(
+    askId: string,
+    selected?: string[],
+    customInput?: string
+  ): Promise<void> {
+    await userInteractionManager.receiveAnswer(askId, selected, customInput);
+  }
+}
+
+/**
+ * 全局对话会话管理
+ */
+class DialogManager {
+  private currentSession: DialogSession | null = null;
+
+  /**
+   * 创建新会话
+   * @param extensionPath 扩展路径
+   * @param existingTaskId 可选，复用现有的 taskId（用于 Plan 模式确认后继续执行）
+   */
+  createSession(extensionPath: string, existingTaskId?: string): DialogSession {
+    // 如果有活跃会话，先中止
+    if (this.currentSession?.active) {
+      this.currentSession.abort();
+    }
+    this.currentSession = new DialogSession(extensionPath, existingTaskId);
+    return this.currentSession;
+  }
+
+  /**
+   * 获取当前会话
+   */
+  getCurrentSession(): DialogSession | null {
+    return this.currentSession;
+  }
+
+  /**
+   * 中止当前会话
+   */
+  abortCurrentSession(): void {
+    this.currentSession?.abort();
+  }
+}
+
+export const dialogManager = new DialogManager();

src/services/icCoderAuthProvider.ts

@@ -0,0 +1,444 @@
+import * as vscode from "vscode";
+import * as http from "http";
+import * as path from "path";
+import * as fs from "fs";
+import { onTokenReceived, type UserInfo, clearUserInfo } from "./userService";
+
+/**
+ * IC Coder Authentication Provider
+ * 集成到 VSCode 账户系统
+ */
+export class ICCoderAuthenticationProvider
+  implements vscode.AuthenticationProvider
+{
+  private static readonly AUTH_TYPE = "iccoder";
+  private static readonly AUTH_NAME = "IC Coder";
+  private static readonly LOGIN_URL = "http://192.168.1.108:2005/login";
+  private static loginServer: http.Server | null = null;
+  private static currentPort: number | null = null;
+
+  private _onDidChangeSessions =
+    new vscode.EventEmitter<vscode.AuthenticationProviderAuthenticationSessionsChangeEvent>();
+  public readonly onDidChangeSessions = this._onDidChangeSessions.event;
+
+  private _sessions: vscode.AuthenticationSession[] = [];
+
+  constructor(private readonly context: vscode.ExtensionContext) {
+    // 从存储中恢复会话
+    this.loadSessions();
+  }
+
+  /**
+   * 从存储中加载会话
+   */
+  private async loadSessions(): Promise<void> {
+    const storedSessions = this.context.globalState.get<
+      vscode.AuthenticationSession[]
+    >("icCoderSessions", []);
+    this._sessions = storedSessions;
+  }
+
+  /**
+   * 保存会话到存储
+   */
+  private async saveSessions(): Promise<void> {
+    await this.context.globalState.update("icCoderSessions", this._sessions);
+  }
+
+  /**
+   * 获取会话列表
+   */
+  async getSessions(
+    scopes?: readonly string[]
+  ): Promise<vscode.AuthenticationSession[]> {
+    return [...this._sessions];
+  }
+
+  /**
+   * 创建会话（登录）
+   */
+  async createSession(
+    scopes: readonly string[]
+  ): Promise<vscode.AuthenticationSession> {
+    try {
+      const token = await this.login();
+
+      // 获取到 token 后立即调用用户信息接口
+      const userInfo = await onTokenReceived(token);
+
+      // 创建会话
+      const session: vscode.AuthenticationSession = {
+        id: this.generateSessionId(),
+        accessToken: token,
+        account: {
+          id: userInfo?.userId || "iccoder-user",
+          label: userInfo?.nickname || userInfo?.username || "IC Coder 用户",
+        },
+        scopes: [...scopes],
+      };
+
+      this._sessions.push(session);
+      await this.saveSessions();
+
+      // 触发会话变化事件
+      this._onDidChangeSessions.fire({
+        added: [session],
+        removed: [],
+        changed: [],
+      });
+
+      vscode.window.showInformationMessage("登录成功！窗口将自动刷新...");
+
+      // 延迟 1 秒后重新加载窗口，让用户看到成功消息
+      setTimeout(() => {
+        vscode.commands.executeCommand("workbench.action.reloadWindow");
+      }, 1000);
+
+      return session;
+    } catch (error) {
+      vscode.window.showErrorMessage(
+        `登录失败: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+
+  /**
+   * 删除会话（登出）
+   */
+  async removeSession(sessionId: string): Promise<void> {
+    const sessionIndex = this._sessions.findIndex((s) => s.id === sessionId);
+    if (sessionIndex > -1) {
+      const session = this._sessions[sessionIndex];
+      this._sessions.splice(sessionIndex, 1);
+      await this.saveSessions();
+
+      // 清除用户信息缓存
+      await clearUserInfo();
+
+      // 触发会话变化事件
+      this._onDidChangeSessions.fire({
+        added: [],
+        removed: [session],
+        changed: [],
+      });
+
+      vscode.window.showInformationMessage("已退出登录！窗口将自动刷新...");
+
+      // 延迟 1 秒后重新加载窗口，让用户看到成功消息
+      setTimeout(() => {
+        vscode.commands.executeCommand("workbench.action.reloadWindow");
+      }, 1000);
+    }
+  }
+
+  /**
+   * 生成会话 ID
+   */
+  private generateSessionId(): string {
+    return `iccoder-${Date.now()}-${Math.random().toString(36).substring(7)}`;
+  }
+
+  /**
+   * 登录逻辑（打开浏览器并等待回调）
+   */
+  private async login(): Promise<string> {
+    // 如果已有服务器在运行，先关闭
+    if (ICCoderAuthenticationProvider.loginServer) {
+      ICCoderAuthenticationProvider.loginServer.close();
+      ICCoderAuthenticationProvider.loginServer = null;
+    }
+
+    // 创建本地服务器监听回调
+    const { server, port } = await this.createCallbackServer();
+    ICCoderAuthenticationProvider.loginServer = server;
+    ICCoderAuthenticationProvider.currentPort = port;
+
+    // 构建登录 URL
+    const callbackUrl = `http://localhost:${port}/callback`;
+    const loginUrl = `${
+      ICCoderAuthenticationProvider.LOGIN_URL
+    }?redirect_uri=${encodeURIComponent(callbackUrl)}`;
+
+    console.log("🔐 登录服务器已启动，监听端口:", port);
+    console.log("🌐 登录 URL:", loginUrl);
+
+    // 打开浏览器登录
+    await vscode.env.openExternal(vscode.Uri.parse(loginUrl));
+
+    vscode.window.showInformationMessage(
+      "请在浏览器中完成登录，登录成功后将自动返回..."
+    );
+
+    // 等待 token（通过 Promise）
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (ICCoderAuthenticationProvider.loginServer) {
+          ICCoderAuthenticationProvider.loginServer.close();
+          ICCoderAuthenticationProvider.loginServer = null;
+          reject(new Error("登录超时"));
+        }
+      }, 5 * 60 * 1000);
+
+      // 将 resolve 和 reject 保存到服务器上下文
+      (server as any)._loginResolve = resolve;
+      (server as any)._loginReject = reject;
+      (server as any)._loginTimeout = timeout;
+    });
+  }
+
+  /**
+   * 创建本地回调服务器
+   */
+  private createCallbackServer(): Promise<{
+    server: http.Server;
+    port: number;
+  }> {
+    return new Promise((resolve, reject) => {
+      // 读取 icon.png 并转换为 Base64
+      const iconPath = path.join(
+        this.context.extensionPath,
+        "media",
+        "icon.png"
+      );
+      let iconBase64 = "";
+      try {
+        const iconBuffer = fs.readFileSync(iconPath);
+        iconBase64 = `data:image/png;base64,${iconBuffer.toString("base64")}`;
+      } catch (error) {
+        console.warn("无法读取 icon.png:", error);
+      }
+
+      const server = http.createServer(async (req, res) => {
+        try {
+          console.log("📥 收到回调请求:", req.url);
+
+          const url = new URL(
+            req.url!,
+            `http://localhost:${ICCoderAuthenticationProvider.currentPort}`
+          );
+          console.log("📍 路径:", url.pathname);
+          console.log("📋 所有参数:", Object.fromEntries(url.searchParams));
+
+          if (url.pathname === "/callback") {
+            const token = url.searchParams.get("token");
+            console.log("🔑 Token:", token ? "已获取" : "未找到");
+
+            if (token) {
+              // 返回成功页面
+              res.writeHead(200, {
+                "Content-Type": "text/html; charset=utf-8",
+              });
+              res.end(this.getSuccessPage(iconBase64));
+
+              // 关闭服务器
+              server.close();
+              ICCoderAuthenticationProvider.loginServer = null;
+
+              // 清除超时
+              if ((server as any)._loginTimeout) {
+                clearTimeout((server as any)._loginTimeout);
+              }
+
+              // 返回 token
+              if ((server as any)._loginResolve) {
+                (server as any)._loginResolve(token);
+              }
+            } else {
+              res.writeHead(400, {
+                "Content-Type": "text/html; charset=utf-8",
+              });
+              res.end(`
+                <!DOCTYPE html>
+                <html>
+                <head><meta charset="utf-8"><title>登录失败</title></head>
+                <body><h1>❌ 登录失败</h1><p>未获取到有效的 Token</p></body>
+                </html>
+              `);
+
+              if ((server as any)._loginReject) {
+                (server as any)._loginReject(new Error("未获取到有效的 Token"));
+              }
+            }
+          } else {
+            res.writeHead(404);
+            res.end("Not Found");
+          }
+        } catch (error) {
+          res.writeHead(500);
+          res.end("Internal Server Error");
+          if ((server as any)._loginReject) {
+            (server as any)._loginReject(error);
+          }
+        }
+      });
+
+      // 监听端口（使用 0 表示自动分配可用端口）
+      server.listen(0, () => {
+        const address = server.address();
+        const port =
+          typeof address === "object" && address ? address.port : 3000;
+        resolve({ server, port });
+      });
+
+      // 处理错误
+      server.on("error", (error: NodeJS.ErrnoException) => {
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * 获取登录成功页面 HTML
+   */
+  private getSuccessPage(iconBase64: string): string {
+    return `
+      <!DOCTYPE html>
+      <html>
+      <head>
+        <meta charset="utf-8">
+        <meta name="viewport" content="width=device-width, initial-scale=1.0">
+        <title>登录成功 - IC Coder</title>
+        <style>
+          * { margin: 0; padding: 0; box-sizing: border-box; }
+          body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            min-height: 100vh;
+            background: linear-gradient(135deg, #dbeafe 0%, #93c5fd 100%);
+            overflow: hidden;
+            position: relative;
+          }
+          .bg-circle {
+            position: absolute;
+            border-radius: 50%;
+            background: rgba(255, 255, 255, 0.1);
+            animation: float 20s infinite ease-in-out;
+          }
+          .bg-circle:nth-child(1) { width: 300px; height: 300px; top: -150px; left: -150px; }
+          .bg-circle:nth-child(2) { width: 200px; height: 200px; bottom: -100px; right: -100px; animation-delay: 5s; }
+          .bg-circle:nth-child(3) { width: 150px; height: 150px; top: 50%; right: 10%; animation-delay: 10s; }
+          @keyframes float {
+            0%, 100% { transform: translate(0, 0) scale(1); }
+            33% { transform: translate(30px, -30px) scale(1.1); }
+            66% { transform: translate(-20px, 20px) scale(0.9); }
+          }
+          .container {
+            position: relative;
+            z-index: 10;
+            text-align: center;
+            background: rgba(255, 255, 255, 0.95);
+            backdrop-filter: blur(10px);
+            padding: 60px 50px;
+            border-radius: 24px;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.3);
+            max-width: 500px;
+            animation: slideUp 0.6s ease-out;
+          }
+          @keyframes slideUp {
+            from { opacity: 0; transform: translateY(30px); }
+            to { opacity: 1; transform: translateY(0); }
+          }
+          .success-icon {
+            width: 80px;
+            height: 80px;
+            margin: 0 auto 30px;
+            background: linear-gradient(135deg, #60a5fa 0%, #3b82f6 100%);
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            animation: scaleIn 0.5s ease-out 0.2s both;
+          }
+          @keyframes scaleIn {
+            from { transform: scale(0); opacity: 0; }
+            to { transform: scale(1); opacity: 1; }
+          }
+          .checkmark {
+            width: 40px;
+            height: 40px;
+            border: 4px solid white;
+            border-radius: 50%;
+            position: relative;
+          }
+          .checkmark::after {
+            content: '';
+            position: absolute;
+            left: 8px;
+            top: 3px;
+            width: 12px;
+            height: 20px;
+            border: solid white;
+            border-width: 0 4px 4px 0;
+            transform: rotate(45deg);
+          }
+          h1 {
+            color: #2d3748;
+            font-size: 32px;
+            font-weight: 700;
+            margin-bottom: 16px;
+            animation: fadeIn 0.6s ease-out 0.3s both;
+          }
+          p {
+            color: #718096;
+            font-size: 18px;
+            line-height: 1.6;
+            margin-bottom: 30px;
+            animation: fadeIn 0.6s ease-out 0.4s both;
+          }
+          @keyframes fadeIn {
+            from { opacity: 0; }
+            to { opacity: 1; }
+          }
+          .brand {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            gap: 10px;
+            margin-top: 20px;
+            padding-top: 20px;
+            border-top: 1px solid #e2e8f0;
+            animation: fadeIn 0.6s ease-out 0.5s both;
+          }
+          .brand-logo {
+            width: 32px;
+            height: 32px;
+            border-radius: 6px;
+            overflow: hidden;
+          }
+          .brand-logo img {
+            width: 100%;
+            height: 100%;
+            object-fit: cover;
+          }
+          .brand-text {
+            color: #4a5568;
+            font-size: 16px;
+            font-weight: 600;
+          }
+        </style>
+      </head>
+      <body>
+        <div class="bg-circle"></div>
+        <div class="bg-circle"></div>
+        <div class="bg-circle"></div>
+        <div class="container">
+          <div class="success-icon">
+            <div class="checkmark"></div>
+          </div>
+          <h1>登录成功！</h1>
+          <p>您已成功登录 IC Coder<br>现在可以返回 VSCode 继续使用</p>
+          <div class="brand">
+            <div class="brand-logo">
+              <img src="${iconBase64}" alt="IC Coder" />
+            </div>
+            <span class="brand-text">IC Coder</span>
+          </div>
+        </div>
+      </body>
+      </html>
+    `;
+  }
+}

src/services/sseHandler.ts

@@ -0,0 +1,349 @@
+/**
+ * SSE 事件处理器
+ * 处理与后端的流式通信
+ * 使用 eventsource-parser + Node.js 原生 http 模块
+ */
+import * as http from 'http';
+import * as https from 'https';
+import { URL } from 'url';
+import { createParser, type EventSourceParser } from 'eventsource-parser';
+import { getApiUrl, getConfig } from '../config/settings';
+import type {
+  DialogRequest,
+  SSEEventType,
+  TextDeltaEvent,
+  ToolCallRequest,
+  ToolConfirmEvent,
+  PlanConfirmEvent,
+  AskUserEvent,
+  CompleteEvent,
+  ErrorEvent,
+  ToolStartEvent,
+  ToolCompleteEvent,
+  ToolErrorEvent,
+  WarningEvent,
+  NotificationEvent,
+  DepthUpdateEvent,
+  AgentStartEvent,
+  AgentProgressEvent,
+  AgentCompleteEvent,
+  AgentErrorEvent,
+  ContextUsageEvent
+} from '../types/api';
+import type { MemoryCompactedEvent } from '../types/memory';
+
+/**
+ * SSE 事件回调接口
+ */
+export interface SSECallbacks {
+  /** 收到文本增量 */
+  onTextDelta?: (data: TextDeltaEvent) => void;
+  /** 收到工具调用请求 */
+  onToolCall?: (data: ToolCallRequest) => void;
+  /** 收到工具确认请求（Ask 模式） */
+  onToolConfirm?: (data: ToolConfirmEvent) => void;
+  /** 收到计划确认请求（Plan 模式） */
+  onPlanConfirm?: (data: PlanConfirmEvent) => void;
+  /** 工具开始执行 */
+  onToolStart?: (data: ToolStartEvent) => void;
+  /** 工具执行完成 */
+  onToolComplete?: (data: ToolCompleteEvent) => void;
+  /** 工具执行错误 */
+  onToolError?: (data: ToolErrorEvent) => void;
+  /** 收到用户提问 */
+  onAskUser?: (data: AskUserEvent) => void;
+  /** 对话完成 */
+  onComplete?: (data: CompleteEvent) => void;
+  /** 错误 */
+  onError?: (data: ErrorEvent) => void;
+  /** 警告 */
+  onWarning?: (data: WarningEvent) => void;
+  /** 通知 */
+  onNotification?: (data: NotificationEvent) => void;
+  /** 深度更新 */
+  onDepthUpdate?: (data: DepthUpdateEvent) => void;
+  /** 子智能体启动 */
+  onAgentStart?: (data: AgentStartEvent) => void;
+  /** 子智能体进度 */
+  onAgentProgress?: (data: AgentProgressEvent) => void;
+  /** 子智能体完成 */
+  onAgentComplete?: (data: AgentCompleteEvent) => void;
+  /** 子智能体错误 */
+  onAgentError?: (data: AgentErrorEvent) => void;
+  /** 记忆压缩完成 */
+  onMemoryCompacted?: (data: MemoryCompactedEvent) => void;
+  /** 上下文使用量更新 */
+  onContextUsage?: (data: ContextUsageEvent) => void;
+  /** 连接打开 */
+  onOpen?: () => void;
+  /** 连接关闭 */
+  onClose?: () => void;
+}
+
+/**
+ * SSE 会话控制器
+ */
+export class SSEController {
+  private request: http.ClientRequest | null = null;
+  private isConnected = false;
+  private isAborted = false;
+
+  /**
+   * 是否已连接
+   */
+  get connected(): boolean {
+    return this.isConnected;
+  }
+
+  /**
+   * 设置请求对象
+   */
+  setRequest(req: http.ClientRequest): void {
+    this.request = req;
+  }
+
+  /**
+   * 设置连接状态
+   */
+  setConnected(connected: boolean): void {
+    this.isConnected = connected;
+  }
+
+  /**
+   * 是否已中止
+   */
+  get aborted(): boolean {
+    return this.isAborted;
+  }
+
+  /**
+   * 中止当前连接
+   */
+  abort(): void {
+    if (this.request && !this.isAborted) {
+      this.isAborted = true;
+      this.request.destroy();
+      this.request = null;
+      this.isConnected = false;
+    }
+  }
+}
+
+/**
+ * 发起流式对话
+ * @param request 对话请求
+ * @param callbacks 事件回调
+ * @returns SSE 控制器（用于中止连接）
+ */
+export async function startStreamDialog(
+  request: DialogRequest,
+  callbacks: SSECallbacks
+): Promise<SSEController> {
+  const controller = new SSEController();
+
+  const urlString = getApiUrl('/api/dialog/stream');
+  const url = new URL(urlString);
+  const isHttps = url.protocol === 'https:';
+  const httpModule = isHttps ? https : http;
+
+  const body = JSON.stringify(request);
+
+  console.log(`[SSE] 开始流式对话: taskId=${request.taskId}, mode=${request.mode}, url=${urlString}`);
+
+  return new Promise((resolve, reject) => {
+    const options: http.RequestOptions = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Content-Length': Buffer.byteLength(body)
+      }
+    };
+
+    const req = httpModule.request(options, (res) => {
+      // 检查响应状态
+      if (res.statusCode !== 200) {
+        let errorBody = '';
+        res.on('data', chunk => errorBody += chunk);
+        res.on('end', () => {
+          const error = new Error(`SSE 连接失败: ${res.statusCode} ${errorBody}`);
+          callbacks.onError?.({ message: error.message });
+          reject(error);
+        });
+        return;
+      }
+
+      // 连接成功
+      console.log('[SSE] 连接已建立');
+      controller.setConnected(true);
+      callbacks.onOpen?.();
+      resolve(controller);
+
+      // 创建 SSE 解析器
+      const parser = createParser({
+        onEvent: (event) => {
+          const eventType = event.event as SSEEventType;
+          const eventData = event.data;
+
+          if (!eventData) {
+            console.log(`[SSE] 收到空事件: ${eventType}`);
+            return;
+          }
+
+          try {
+            const data = JSON.parse(eventData);
+            console.log(`[SSE] 收到事件: ${eventType}`, data);
+
+            // 分发事件到对应回调
+            dispatchEvent(eventType, data, callbacks);
+          } catch (e) {
+            console.error(`[SSE] 解析事件数据失败: ${eventData}`, e);
+          }
+        }
+      });
+
+      // 设置编码
+      res.setEncoding('utf8');
+
+      // 处理数据流
+      res.on('data', (chunk: string) => {
+        if (!controller.aborted) {
+          console.log('[SSE] 收到原始数据块:', chunk.substring(0, 200));
+          parser.feed(chunk);
+        }
+      });
+
+      // 处理连接关闭
+      res.on('end', () => {
+        console.log('[SSE] 连接已关闭');
+        controller.setConnected(false);
+        callbacks.onClose?.();
+      });
+
+      // 处理错误
+      res.on('error', (err) => {
+        if (!controller.aborted) {
+          console.error('[SSE] 响应错误:', err);
+          controller.setConnected(false);
+          callbacks.onError?.({ message: err.message });
+        }
+      });
+    });
+
+    // 保存请求引用用于中止
+    controller.setRequest(req);
+
+    // 处理请求错误
+    req.on('error', (err) => {
+      if (!controller.aborted) {
+        console.error('[SSE] 请求错误:', err);
+        controller.setConnected(false);
+        callbacks.onError?.({ message: err.message });
+        reject(err);
+      }
+    });
+
+    // 处理超时
+    const { timeout } = getConfig();
+    req.setTimeout(timeout, () => {
+      if (!controller.aborted) {
+        console.error('[SSE] 请求超时');
+        controller.abort();
+        const error = new Error('请求超时');
+        callbacks.onError?.({ message: error.message });
+        reject(error);
+      }
+    });
+
+    // 发送请求体
+    req.write(body);
+    req.end();
+  });
+}
+
+/**
+ * 分发 SSE 事件到对应回调
+ */
+function dispatchEvent(
+  eventType: SSEEventType,
+  data: unknown,
+  callbacks: SSECallbacks
+): void {
+  switch (eventType) {
+    case 'text_delta':
+      callbacks.onTextDelta?.(data as TextDeltaEvent);
+      break;
+    case 'tool_call':
+      callbacks.onToolCall?.(data as ToolCallRequest);
+      break;
+    case 'tool_confirm':
+      callbacks.onToolConfirm?.(data as ToolConfirmEvent);
+      break;
+    case 'plan_confirm':
+      callbacks.onPlanConfirm?.(data as PlanConfirmEvent);
+      break;
+    case 'tool_start':
+      callbacks.onToolStart?.(data as ToolStartEvent);
+      break;
+    case 'tool_complete':
+      callbacks.onToolComplete?.(data as ToolCompleteEvent);
+      break;
+    case 'tool_error':
+      callbacks.onToolError?.(data as ToolErrorEvent);
+      break;
+    case 'ask_user':
+      callbacks.onAskUser?.(data as AskUserEvent);
+      break;
+    case 'complete':
+      callbacks.onComplete?.(data as CompleteEvent);
+      break;
+    case 'error':
+      callbacks.onError?.(data as ErrorEvent);
+      break;
+    case 'warning':
+      callbacks.onWarning?.(data as WarningEvent);
+      break;
+    case 'notification':
+      callbacks.onNotification?.(data as NotificationEvent);
+      break;
+    case 'depth_update':
+      callbacks.onDepthUpdate?.(data as DepthUpdateEvent);
+      break;
+    case 'agent_start':
+      callbacks.onAgentStart?.(data as AgentStartEvent);
+      break;
+    case 'agent_progress':
+      callbacks.onAgentProgress?.(data as AgentProgressEvent);
+      break;
+    case 'agent_complete':
+      callbacks.onAgentComplete?.(data as AgentCompleteEvent);
+      break;
+    case 'agent_error':
+      callbacks.onAgentError?.(data as AgentErrorEvent);
+      break;
+    case 'memory_compacted':
+      callbacks.onMemoryCompacted?.(data as MemoryCompactedEvent);
+      break;
+    case 'context_usage':
+      callbacks.onContextUsage?.(data as ContextUsageEvent);
+      break;
+    case 'heartbeat':
+      // 心跳事件：仅用于保持连接，不需要特殊处理
+      // Node.js req.setTimeout 会在收到数据时自动重置计时器
+      console.log('[SSE] 收到心跳');
+      break;
+    default:
+      console.log(`[SSE] 未知事件类型: ${eventType}`, data);
+  }
+}
+
+/**
+ * 生成任务ID
+ */
+export function generateTaskId(): string {
+  return `task-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+}

src/services/toolExecutor.ts

@@ -0,0 +1,422 @@
+/**
+ * 工具执行器
+ * 接收后端的 tool_call 事件，执行本地工具，返回结果
+ */
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as os from 'os';
+import * as fs from 'fs';
+import { readFileContent, readDirectory } from '../utils/readFiles';
+import { createOrOverwriteFile } from '../utils/createFiles';
+import { generateVCD, checkIverilogAvailable } from '../utils/iverilogRunner';
+import { analyzeVcdFile } from '../utils/vcdParser';
+import { executeWaveformTrace, WaveformTraceArgs } from '../utils/waveformTracer';
+import {
+  submitToolResult,
+  createSuccessResult,
+  createBusinessErrorResult,
+  createSystemErrorResult
+} from './apiClient';
+import type {
+  ToolCallRequest,
+  ToolName,
+  FileReadArgs,
+  FileWriteArgs,
+  FileDeleteArgs,
+  FileListArgs,
+  SyntaxCheckArgs,
+  SimulationArgs,
+  WaveformSummaryArgs,
+  KnowledgeSaveArgs,
+  KnowledgeLoadArgs
+} from '../types/api';
+
+/**
+ * 工具执行器上下文
+ */
+export interface ToolExecutorContext {
+  /** 扩展路径（用于 iverilog） */
+  extensionPath: string;
+  /** 工作区路径 */
+  workspacePath: string;
+}
+
+/**
+ * 执行工具调用
+ * @param request 工具调用请求
+ * @param context 执行上下文
+ */
+export async function executeToolCall(
+  request: ToolCallRequest,
+  context: ToolExecutorContext
+): Promise<void> {
+  const toolName = request.params.name as ToolName;
+  const args = request.params.arguments;
+  const callId = request.id;
+
+  console.log(`[ToolExecutor] 执行工具: ${toolName}, callId=${callId}`, args);
+
+  try {
+    let resultText: string;
+
+    switch (toolName) {
+      case 'file_read':
+        resultText = await executeFileRead(args as unknown as FileReadArgs);
+        break;
+      case 'file_write':
+        resultText = await executeFileWrite(args as unknown as FileWriteArgs);
+        break;
+      case 'file_delete':
+        resultText = await executeFileDelete(args as unknown as FileDeleteArgs);
+        break;
+      case 'file_list':
+        resultText = await executeFileList(args as unknown as FileListArgs);
+        break;
+      case 'syntax_check':
+        resultText = await executeSyntaxCheck(args as unknown as SyntaxCheckArgs, context);
+        break;
+      case 'simulation':
+        resultText = await executeSimulation(args as unknown as SimulationArgs, context);
+        break;
+      case 'waveform_summary':
+        resultText = await executeWaveformSummary(args as unknown as WaveformSummaryArgs);
+        break;
+      case 'waveform_trace':
+        resultText = await executeWaveformTrace(args as unknown as WaveformTraceArgs, context);
+        break;
+      case 'knowledge_save':
+        resultText = await executeKnowledgeSave(args as unknown as KnowledgeSaveArgs);
+        break;
+      case 'knowledge_load':
+        resultText = await executeKnowledgeLoad();
+        break;
+      default:
+        throw new Error(`未知工具: ${toolName}`);
+    }
+
+    // 提交成功结果
+    const result = createSuccessResult(callId, resultText);
+    await submitToolResult(result);
+    console.log(`[ToolExecutor] 工具执行成功: ${toolName}, callId=${callId}`);
+
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : '未知错误';
+    console.error(`[ToolExecutor] 工具执行失败: ${toolName}, callId=${callId}`, error);
+
+    // 提交错误结果
+    const result = createBusinessErrorResult(callId, errorMessage);
+    await submitToolResult(result);
+  }
+}
+
+/**
+ * 执行 file_read 工具
+ */
+async function executeFileRead(args: FileReadArgs): Promise<string> {
+  const content = await readFileContent(args.path);
+  return content;
+}
+
+/**
+ * 执行 file_write 工具
+ */
+async function executeFileWrite(args: FileWriteArgs): Promise<string> {
+  await createOrOverwriteFile(args.path, args.content);
+
+  // Verilog 文件添加知识图谱提示
+  const isVerilogFile = args.path.endsWith('.v') || args.path.endsWith('.sv');
+  if (isVerilogFile) {
+    return `文件已写入: ${args.path}\n\n[提示] 如有新信号或规则，请更新知识图谱`;
+  }
+
+  return `文件已写入: ${args.path}`;
+}
+
+/**
+ * 执行 file_delete 工具
+ * 删除指定路径的文件
+ */
+async function executeFileDelete(args: FileDeleteArgs): Promise<string> {
+  const filePath = args.path;
+
+  // 获取工作区路径
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  if (!workspaceFolders || workspaceFolders.length === 0) {
+    throw new Error('请先打开一个工作区');
+  }
+
+  const workspacePath = workspaceFolders[0].uri.fsPath;
+
+  // 解析文件路径（支持相对路径和绝对路径）
+  const absolutePath = path.isAbsolute(filePath)
+    ? filePath
+    : path.join(workspacePath, filePath);
+
+  // 检查文件是否存在
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`文件不存在: ${filePath}`);
+  }
+
+  // 检查是否为文件（不允许删除目录）
+  const stat = fs.statSync(absolutePath);
+  if (stat.isDirectory()) {
+    throw new Error(`不能删除目录，请指定文件路径: ${filePath}`);
+  }
+
+  // 删除文件
+  fs.unlinkSync(absolutePath);
+
+  // Verilog 文件添加知识图谱提示
+  const isVerilogFile = filePath.endsWith('.v') || filePath.endsWith('.sv');
+  if (isVerilogFile) {
+    return `文件已删除: ${filePath}\n\n[提示] 请删除知识图谱中相关节点`;
+  }
+
+  return `文件已删除: ${filePath}`;
+}
+
+/**
+ * 执行 file_list 工具
+ */
+async function executeFileList(args: FileListArgs): Promise<string> {
+  const dirPath = args.path || '.';
+  const extensions = args.extension ? [args.extension] : undefined;
+
+  const files = await readDirectory(dirPath, extensions);
+  const fileList = files.map(f => f.path).join('\n');
+
+  return fileList || '（目录为空）';
+}
+
+/**
+ * 执行 syntax_check 工具
+ * 将代码写入临时文件，调用 iverilog 检查语法
+ */
+async function executeSyntaxCheck(
+  args: SyntaxCheckArgs,
+  context: ToolExecutorContext
+): Promise<string> {
+  // 检查 iverilog 是否可用
+  const iverilogCheck = await checkIverilogAvailable(context.extensionPath);
+  if (!iverilogCheck.available) {
+    throw new Error(`iverilog 不可用: ${iverilogCheck.message}`);
+  }
+
+  // 创建临时文件
+  const tempDir = os.tmpdir();
+  const tempFile = path.join(tempDir, `iccoder_syntax_${Date.now()}.v`);
+
+  try {
+    // 写入代码到临时文件
+    fs.writeFileSync(tempFile, args.code, 'utf-8');
+
+    // 调用 iverilog 进行语法检查
+    const { spawn } = require('child_process');
+    const iverilogPath = getIverilogPath(context.extensionPath);
+
+    return new Promise((resolve, reject) => {
+      const child = spawn(iverilogPath, ['-t', 'null', tempFile], {
+        cwd: tempDir,
+        env: {
+          ...process.env,
+          IVERILOG_ROOT: path.join(context.extensionPath, 'tools', 'iverilog')
+        }
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout.on('data', (data: Buffer) => {
+        stdout += data.toString();
+      });
+
+      child.stderr.on('data', (data: Buffer) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code: number) => {
+        // 清理临时文件
+        try {
+          fs.unlinkSync(tempFile);
+        } catch (e) {
+          // 忽略清理错误
+        }
+
+        if (code === 0) {
+          resolve('语法检查通过，无错误。');
+        } else {
+          resolve(`语法检查发现错误:\n${stderr || stdout}`);
+        }
+      });
+
+      child.on('error', (error: Error) => {
+        try {
+          fs.unlinkSync(tempFile);
+        } catch (e) {
+          // 忽略清理错误
+        }
+        reject(error);
+      });
+    });
+
+  } catch (error) {
+    // 确保清理临时文件
+    try {
+      fs.unlinkSync(tempFile);
+    } catch (e) {
+      // 忽略
+    }
+    throw error;
+  }
+}
+
+/**
+ * 执行 simulation 工具
+ */
+async function executeSimulation(
+  args: SimulationArgs,
+  context: ToolExecutorContext
+): Promise<string> {
+  // 获取工作区路径
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  if (!workspaceFolders || workspaceFolders.length === 0) {
+    throw new Error('请先打开一个工作区');
+  }
+
+  const projectPath = workspaceFolders[0].uri.fsPath;
+
+  // 调用现有的 generateVCD 函数
+  const result = await generateVCD(projectPath, context.extensionPath);
+
+  if (result.success) {
+    let message = result.message;
+    if (result.stdout) {
+      message += `\n\n仿真输出:\n${result.stdout}`;
+    }
+    return message;
+  } else {
+    let errorMessage = result.message;
+    if (result.stderr) {
+      errorMessage += `\n\n错误输出:\n${result.stderr}`;
+    }
+    throw new Error(errorMessage);
+  }
+}
+
+/**
+ * 执行 waveform_summary 工具
+ * 解析 VCD 文件并返回波形摘要
+ */
+async function executeWaveformSummary(args: WaveformSummaryArgs): Promise<string> {
+  const { vcdPath, signals, checkpoints } = args;
+
+  // 获取工作区路径
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  if (!workspaceFolders || workspaceFolders.length === 0) {
+    throw new Error('请先打开一个工作区');
+  }
+
+  const workspacePath = workspaceFolders[0].uri.fsPath;
+
+  // 解析 VCD 文件路径（支持相对路径）
+  const absolutePath = path.isAbsolute(vcdPath)
+    ? vcdPath
+    : path.join(workspacePath, vcdPath);
+
+  // 检查文件是否存在
+  if (!fs.existsSync(absolutePath)) {
+    throw new Error(`VCD 文件不存在: ${vcdPath}`);
+  }
+
+  // 解析检查点时间
+  const checkpoint = checkpoints ? parseInt(checkpoints, 10) : undefined;
+
+  // 调用 VCD 解析器
+  const result = analyzeVcdFile(absolutePath, signals, checkpoint);
+
+  return result;
+}
+
+/**
+ * 执行 knowledge_save 工具
+ * 保存知识图谱到 .iccoder/knowledge.json
+ */
+async function executeKnowledgeSave(args: KnowledgeSaveArgs): Promise<string> {
+  const workspaceFolder = getWorkspaceFolder();
+  if (!workspaceFolder) {
+    throw new Error('请先打开一个工作区');
+  }
+
+  const iccoderDirUri = vscode.Uri.joinPath(workspaceFolder.uri, '.iccoder');
+  const knowledgeUri = vscode.Uri.joinPath(iccoderDirUri, 'knowledge.json');
+
+  // 确保 .iccoder 目录存在（兼容远程/虚拟工作区）
+  await vscode.workspace.fs.createDirectory(iccoderDirUri);
+
+  // 写入知识图谱（UTF-8）
+  await vscode.workspace.fs.writeFile(knowledgeUri, Buffer.from(args.data || '', 'utf-8'));
+
+  return `知识图谱已保存: .iccoder/knowledge.json`;
+}
+
+/**
+ * 执行 knowledge_load 工具
+ * 从 .iccoder/knowledge.json 加载知识图谱
+ */
+async function executeKnowledgeLoad(): Promise<string> {
+  const workspaceFolder = getWorkspaceFolder();
+  if (!workspaceFolder) {
+    throw new Error('请先打开一个工作区');
+  }
+
+  const knowledgeUri = vscode.Uri.joinPath(workspaceFolder.uri, '.iccoder', 'knowledge.json');
+
+  try {
+    const bytes = await vscode.workspace.fs.readFile(knowledgeUri);
+    const content = Buffer.from(bytes).toString('utf-8');
+    return content;
+  } catch (error) {
+    // 文件不存在：返回空图谱
+    if (error instanceof vscode.FileSystemError && error.code === 'FileNotFound') {
+      // 与后端 KnowledgeGraph 结构保持一致（nodes/edges + nodeClass 多态字段）
+      return JSON.stringify({ taskId: '', version: 1, module: null, nodes: [], edges: [] });
+    }
+    throw error;
+  }
+}
+
+function getWorkspaceFolder(): vscode.WorkspaceFolder | undefined {
+  const folders = vscode.workspace.workspaceFolders;
+  if (!folders || folders.length === 0) {
+    return undefined;
+  }
+
+  const activeUri = vscode.window.activeTextEditor?.document?.uri;
+  const activeFolder = activeUri ? vscode.workspace.getWorkspaceFolder(activeUri) : undefined;
+  return activeFolder ?? folders[0];
+}
+
+/**
+ * 获取 iverilog 路径
+ */
+function getIverilogPath(extensionPath: string): string {
+  const platform = process.platform;
+  if (platform === 'win32') {
+    return path.join(extensionPath, 'tools', 'iverilog', 'bin', 'iverilog.exe');
+  } else {
+    return path.join(extensionPath, 'tools', 'iverilog', 'bin', 'iverilog');
+  }
+}
+
+/**
+ * 创建工具执行器上下文
+ */
+export function createToolExecutorContext(extensionPath: string): ToolExecutorContext {
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  const workspacePath = workspaceFolders?.[0]?.uri.fsPath || '';
+
+  return {
+    extensionPath,
+    workspacePath
+  };
+}

src/services/userInteraction.ts

@@ -0,0 +1,179 @@
+/**
+ * 用户交互处理器
+ * 处理 ask_user 事件，通过 WebView 显示问题并收集用户回答
+ */
+import * as vscode from 'vscode';
+import { submitAnswer, submitToolConfirm } from './apiClient';
+import type { AskUserEvent, AnswerRequest } from '../types/api';
+
+/**
+ * 待处理的用户问题
+ */
+interface PendingQuestion {
+  askId: string;
+  taskId: string;
+  question: string;
+  options: string[];
+  resolve: (answer: string) => void;
+  reject: (error: Error) => void;
+}
+
+/**
+ * 用户交互管理器
+ */
+export class UserInteractionManager {
+  private pendingQuestions = new Map<string, PendingQuestion>();
+  private webviewPanel: vscode.WebviewPanel | null = null;
+
+  /**
+   * 设置 WebView 面板（用于发送消息）
+   */
+  setWebviewPanel(panel: vscode.WebviewPanel): void {
+    this.webviewPanel = panel;
+  }
+
+  /**
+   * 获取 WebView 面板
+   */
+  getWebviewPanel(): vscode.WebviewPanel | null {
+    return this.webviewPanel;
+  }
+
+  /**
+   * 处理 ask_user 事件
+   * @param event ask_user 事件数据
+   * @param taskId 当前任务ID
+   */
+  async handleAskUser(event: AskUserEvent, taskId: string): Promise<void> {
+    const { askId, question, options } = event;
+
+    console.log(`[UserInteraction] 收到问题: askId=${askId}, question=${question}`);
+
+    // 注意：问题显示已经通过 dialogService 的 onSegmentUpdate 统一处理
+    // 这里不再单独发送 showQuestion 命令，避免重复显示
+
+    // 创建 Promise 等待用户回答
+    return new Promise((resolve, reject) => {
+      this.pendingQuestions.set(askId, {
+        askId,
+        taskId,
+        question,
+        options,
+        resolve: (answer: string) => {
+          this.submitUserAnswer(askId, taskId, answer)
+            .then(() => resolve())
+            .catch(reject);
+        },
+        reject
+      });
+
+      // 设置超时（2小时）
+      setTimeout(() => {
+        if (this.pendingQuestions.has(askId)) {
+          this.pendingQuestions.delete(askId);
+          reject(new Error('用户回答超时'));
+        }
+      }, 7200000);
+    });
+  }
+
+  /**
+   * 处理用户提交的回答（从 WebView 调用）
+   * @param askId 问题ID
+   * @param selected 选中的选项
+   * @param customInput 自定义输入
+   */
+  async receiveAnswer(
+    askId: string,
+    selected?: string[],
+    customInput?: string
+  ): Promise<void> {
+    const pending = this.pendingQuestions.get(askId);
+    if (!pending) {
+      console.warn(`[UserInteraction] 问题不存在或已超时: askId=${askId}`);
+      return;
+    }
+
+    // 构建答案
+    const answer = customInput || selected?.join(', ') || '';
+
+    console.log(`[UserInteraction] 收到用户回答: askId=${askId}, answer=${answer}`);
+
+    // 移除待处理问题
+    this.pendingQuestions.delete(askId);
+
+    // 触发 resolve
+    pending.resolve(answer);
+  }
+
+  /**
+   * 提交用户回答到后端
+   */
+  private async submitUserAnswer(
+    askId: string,
+    taskId: string,
+    answer: string
+  ): Promise<void> {
+    // 检查是否是工具确认类型的问题
+    if (askId.startsWith('tool_confirm_')) {
+      // 提取 confirmId
+      const confirmId = parseInt(askId.replace('tool_confirm_', ''));
+      const approved = answer === '确认执行';
+
+      console.log(`[UserInteraction] 提交工具确认: confirmId=${confirmId}, approved=${approved}`);
+
+      try {
+        const response = await submitToolConfirm({
+          confirmId,
+          taskId,
+          approved
+        });
+        if (!response.success) {
+          throw new Error(response.error || '提交工具确认失败');
+        }
+        console.log(`[UserInteraction] 工具确认已提交: confirmId=${confirmId}`);
+      } catch (error) {
+        console.error(`[UserInteraction] 提交工具确认失败: confirmId=${confirmId}`, error);
+        throw error;
+      }
+    } else {
+      // 普通问题回答
+      const request: AnswerRequest = {
+        askId,
+        taskId,
+        customInput: answer
+      };
+
+      try {
+        const response = await submitAnswer(request);
+        if (!response.success) {
+          throw new Error(response.error || '提交回答失败');
+        }
+        console.log(`[UserInteraction] 回答已提交: askId=${askId}`);
+      } catch (error) {
+        console.error(`[UserInteraction] 提交回答失败: askId=${askId}`, error);
+        throw error;
+      }
+    }
+  }
+
+  /**
+   * 取消所有待处理的问题
+   */
+  cancelAll(): void {
+    for (const [askId, pending] of this.pendingQuestions) {
+      pending.reject(new Error('用户交互已取消'));
+    }
+    this.pendingQuestions.clear();
+  }
+
+  /**
+   * 检查是否有待处理的问题
+   */
+  hasPendingQuestions(): boolean {
+    return this.pendingQuestions.size > 0;
+  }
+}
+
+// 全局实例
+export const userInteractionManager = new UserInteractionManager();

src/services/userService.ts

@@ -0,0 +1,345 @@
+/**
+ * 用户服务
+ * 管理用户信息和认证相关的 API 调用
+ */
+import * as https from 'https';
+import * as http from 'http';
+import { URL } from 'url';
+import * as vscode from 'vscode';
+import { getStrangeLoopApiUrl, getConfig } from '../config/settings';
+import type { UserInfoResponse, MembershipResponse, MultiMembershipVO, MembershipItemVO } from '../types/api';
+
+/**
+ * HTTP 请求选项
+ */
+interface RequestOptions {
+  method: 'GET' | 'POST' | 'PUT' | 'DELETE';
+  headers?: Record<string, string>;
+  body?: unknown;
+  timeout?: number;
+  token?: string;
+}
+
+/**
+ * 发送 HTTP 请求（带 token）
+ */
+async function request<T>(path: string, options: RequestOptions): Promise<T> {
+  const url = new URL(getStrangeLoopApiUrl(path));
+  const { timeout } = getConfig();
+
+  const isHttps = url.protocol === 'https:';
+  const httpModule = isHttps ? https : http;
+
+  const headers: Record<string, string> = {
+    'Content-Type': 'application/json',
+    ...options.headers
+  };
+
+  // 如果有 token，添加到请求头
+  if (options.token) {
+    headers['Authorization'] = `Bearer ${options.token}`;
+  }
+
+  const requestOptions: http.RequestOptions = {
+    hostname: url.hostname,
+    port: url.port || (isHttps ? 443 : 80),
+    path: url.pathname + url.search,
+    method: options.method,
+    headers,
+    timeout: options.timeout || timeout
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = httpModule.request(requestOptions, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        console.log(`[HTTP] 响应状态码: ${res.statusCode}`);
+        console.log(`[HTTP] 响应内容: ${data}`);
+
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json as T);
+          } else {
+            reject(new Error(json.error || json.message || json.msg || `HTTP ${res.statusCode}`));
+          }
+        } catch (e) {
+          // 如果不是 JSON，直接返回原始内容
+          reject(new Error(`解析响应失败 (${res.statusCode}): ${data}`));
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('请求超时'));
+    });
+
+    if (options.body) {
+      req.write(JSON.stringify(options.body));
+    }
+
+    req.end();
+  });
+}
+
+/**
+ * 用户信息数据结构（实际返回的数据）
+ */
+export interface UserInfo {
+  userId: string;
+  username: string;
+  nickname: string;
+  email?: string;
+  phonenumber?: string;
+  avatar?: string;
+  roles?: string[];
+  permissions?: string[];
+  createTime?: string;
+  loginDate?: string;
+  // 会员信息
+  membership?: {
+    tierCode: string;
+    tierName: string;
+    tierLevel: number;
+    remainingDays?: number;
+    monthlyCredits?: number;
+  };
+}
+
+/**
+ * 获取用户信息
+ * GET /system/user/getInfo
+ */
+export async function getUserInfo(token: string): Promise<UserInfo | null> {
+  const apiPath = '/system/user/getInfo';
+  const fullUrl = getStrangeLoopApiUrl(apiPath);
+  console.log('[UserService] 获取用户信息');
+  console.log('[UserService] 请求地址:', fullUrl);
+  console.log('[UserService] Token:', token ? '已提供' : '未提供');
+
+  try {
+    const response = await request<UserInfoResponse>(apiPath, {
+      method: 'GET',
+      token
+    });
+
+    // 处理响应数据 - 检查 code 是否为 200
+    if (response.code === 200 && response.user) {
+      const user = response.user;
+      return {
+        userId: String(user.userId),
+        username: user.userName,
+        nickname: user.nickName,
+        email: user.email,
+        phonenumber: user.phonenumber,
+        avatar: user.avatar,
+        roles: response.roles,
+        permissions: response.permissions,
+        createTime: user.createTime,
+        loginDate: user.loginDate
+      };
+    }
+
+    console.error('[UserService] 获取用户信息失败:', response);
+    return null;
+  } catch (error) {
+    console.error('[UserService] 请求失败:', error);
+    return null;
+  }
+}
+
+/**
+ * 获取用户会员信息
+ * GET /strangeloop/api/membership/current
+ */
+export async function getMembershipInfo(token: string): Promise<MultiMembershipVO | null> {
+  const apiPath = '/strangeloop/api/membership/current';
+  const fullUrl = getStrangeLoopApiUrl(apiPath);
+  console.log('[UserService] 获取会员信息');
+  console.log('[UserService] 请求地址:', fullUrl);
+  console.log('[UserService] Token:', token ? '已提供' : '未提供');
+
+  try {
+    const response = await request<MembershipResponse>(apiPath, {
+      method: 'GET',
+      token
+    });
+
+    // 处理响应数据 - 检查 code 是否为 200
+    if (response.code === 200 && response.data) {
+      console.log('[UserService] 会员信息获取成功:', response.data);
+      return response.data;
+    }
+
+    console.error('[UserService] 获取会员信息失败:', response);
+    return null;
+  } catch (error) {
+    console.error('[UserService] 请求会员信息失败:', error);
+    return null;
+  }
+}
+
+/**
+ * 会员等级映射
+ */
+const TIER_LEVEL_MAP: Record<string, number> = {
+  'BASIC': 1,
+  'TRIAL': 2,
+  'ADVANCED': 3,
+  'PROFESSIONAL': 4
+};
+
+/**
+ * 获取最高等级的会员信息
+ */
+function getHighestTierMembership(allMemberships?: MembershipItemVO[]): MembershipItemVO | null {
+  if (!allMemberships || allMemberships.length === 0) {
+    return null;
+  }
+
+  // 按等级排序，获取最高等级
+  return allMemberships.reduce((highest, current) => {
+    const currentLevel = TIER_LEVEL_MAP[current.tierCode] || 0;
+    const highestLevel = TIER_LEVEL_MAP[highest.tierCode] || 0;
+    return currentLevel > highestLevel ? current : highest;
+  });
+}
+
+/**
+ * 当获取到 token 时自动调用此函数
+ * 用于在登录成功后立即获取用户信息
+ */
+export async function onTokenReceived(token: string): Promise<UserInfo | null> {
+  try {
+    console.log('[UserService] Token 已获取，正在获取用户信息和会员信息...');
+
+    // 并行获取用户信息和会员信息
+    const [userInfo, membershipInfo] = await Promise.all([
+      getUserInfo(token),
+      getMembershipInfo(token)
+    ]);
+
+    if (!userInfo) {
+      console.warn('[UserService] 未能获取到用户信息');
+      return null;
+    }
+
+    // 打印用户信息到控制台
+    console.log('='.repeat(60));
+    console.log('用户信息详情:');
+    console.log('='.repeat(60));
+    console.log(`用户ID: ${userInfo.userId}`);
+    console.log(`用户名: ${userInfo.username}`);
+    console.log(`昵称: ${userInfo.nickname}`);
+    if (userInfo.email) {
+      console.log(`邮箱: ${userInfo.email}`);
+    }
+    if (userInfo.phonenumber) {
+      console.log(`手机号: ${userInfo.phonenumber}`);
+    }
+    if (userInfo.avatar) {
+      console.log(`头像: ${userInfo.avatar}`);
+    }
+    if (userInfo.roles && userInfo.roles.length > 0) {
+      console.log(`角色: ${userInfo.roles.join(', ')}`);
+    }
+    if (userInfo.permissions && userInfo.permissions.length > 0) {
+      console.log(`权限: ${userInfo.permissions.join(', ')}`);
+    }
+    if (userInfo.createTime) {
+      console.log(`创建时间: ${userInfo.createTime}`);
+    }
+    if (userInfo.loginDate) {
+      console.log(`最后登录: ${userInfo.loginDate}`);
+    }
+
+    // 打印会员信息 - 从 allMemberships 中获取最高等级
+    if (membershipInfo && membershipInfo.allMemberships) {
+      const highestTier = getHighestTierMembership(membershipInfo.allMemberships);
+
+      if (highestTier) {
+        console.log('');
+        console.log('会员信息:');
+        console.log(`会员等级: ${highestTier.tierName} (${highestTier.tierCode})`);
+        console.log(`等级层级: ${highestTier.tierLevel}`);
+        console.log(`剩余天数: ${highestTier.remainingDays === -1 ? '永久' : highestTier.remainingDays + '天'}`);
+        console.log(`月度积分: ${highestTier.monthlyCredits}`);
+
+        // 将最高等级会员信息合并到用户信息中
+        userInfo.membership = {
+          tierCode: highestTier.tierCode,
+          tierName: highestTier.tierName,
+          tierLevel: highestTier.tierLevel,
+          remainingDays: highestTier.remainingDays,
+          monthlyCredits: highestTier.monthlyCredits
+        };
+      }
+    }
+
+    console.log('='.repeat(60));
+
+    // 保存到持久化存储
+    await saveUserInfo(userInfo);
+
+    return userInfo;
+  } catch (error) {
+    console.error('[UserService] 获取用户信息失败:', error);
+    return null;
+  }
+}
+
+// ============== 持久化存储 ==============
+
+let extensionContext: vscode.ExtensionContext | null = null;
+
+/**
+ * 初始化用户服务（设置 context）
+ */
+export function initUserService(context: vscode.ExtensionContext): void {
+  extensionContext = context;
+}
+
+/**
+ * 保存用户信息到持久化存储
+ */
+export async function saveUserInfo(userInfo: UserInfo): Promise<void> {
+  if (!extensionContext) {
+    console.warn('[UserService] ExtensionContext 未初始化');
+    return;
+  }
+  await extensionContext.globalState.update('icCoderUserInfo', userInfo);
+  console.log('[UserService] 用户信息已保存到持久化存储');
+}
+
+/**
+ * 从持久化存储获取用户信息
+ */
+export function getCachedUserInfo(): UserInfo | null {
+  if (!extensionContext) {
+    console.warn('[UserService] ExtensionContext 未初始化');
+    return null;
+  }
+  return extensionContext.globalState.get<UserInfo>('icCoderUserInfo') || null;
+}
+
+/**
+ * 清除持久化存储的用户信息
+ */
+export async function clearUserInfo(): Promise<void> {
+  if (!extensionContext) {
+    console.warn('[UserService] ExtensionContext 未初始化');
+    return;
+  }
+  await extensionContext.globalState.update('icCoderUserInfo', undefined);
+  console.log('[UserService] 用户信息已清除');
+}

src/services/vcdFileServer.ts

@@ -0,0 +1,500 @@
+import * as http from "http";
+import * as fs from "fs";
+import * as path from "path";
+import * as vscode from "vscode";
+
+/**
+ * VCD 文件 HTTP 服务器
+ * 用于为 Surfer 波形查看器提供 VCD 文件访问
+ */
+export class VCDFileServer {
+  private server: http.Server | null = null;
+  private port: number = 0;
+  private vcdFiles: Map<string, string> = new Map(); // fileId -> filePath
+  private extensionUri: vscode.Uri;
+
+  constructor(extensionUri: vscode.Uri) {
+    this.extensionUri = extensionUri;
+  }
+
+  /**
+   * 启动服务器
+   */
+  public async start(): Promise<number> {
+    if (this.server) {
+      return this.port;
+    }
+
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer((req, res) => {
+        this.handleRequest(req, res);
+      });
+
+      // 监听随机端口
+      this.server.listen(0, "127.0.0.1", () => {
+        const address = this.server!.address();
+        if (address && typeof address === "object") {
+          this.port = address.port;
+          console.log(`[VCDFileServer] 服务器已启动，端口: ${this.port}`);
+          resolve(this.port);
+        } else {
+          reject(new Error("无法获取服务器端口"));
+        }
+      });
+
+      this.server.on("error", (error) => {
+        console.error("[VCDFileServer] 服务器错误:", error);
+        reject(error);
+      });
+    });
+  }
+
+  /**
+   * 停止服务器
+   */
+  public stop(): void {
+    if (this.server) {
+      this.server.close();
+      this.server = null;
+      this.port = 0;
+      this.vcdFiles.clear();
+      console.log("[VCDFileServer] 服务器已停止");
+    }
+  }
+
+  /**
+   * 注册 VCD 文件
+   */
+  public registerFile(filePath: string): string {
+    const fileId = this.generateFileId(filePath);
+    this.vcdFiles.set(fileId, filePath);
+    console.log(`[VCDFileServer] 注册文件: ${fileId} -> ${filePath}`);
+    return fileId;
+  }
+
+  /**
+   * 获取文件 URL
+   */
+  public getFileUrl(fileId: string): string {
+    return `http://127.0.0.1:${this.port}/vcd/${fileId}`;
+  }
+
+  /**
+   * 获取波形查看器 URL
+   */
+  public getViewerUrl(fileId: string): string {
+    return `http://127.0.0.1:${this.port}/viewer/${fileId}`;
+  }
+
+  /**
+   * 生成文件 ID
+   */
+  private generateFileId(filePath: string): string {
+    const timestamp = Date.now();
+    const fileName = path.basename(filePath);
+    return `${timestamp}-${fileName}`;
+  }
+
+  /**
+   * 处理 HTTP 请求
+   */
+  private handleRequest(req: http.IncomingMessage, res: http.ServerResponse): void {
+    const url = req.url || "";
+    console.log(`[VCDFileServer] 收到请求: ${url}`);
+
+    // 设置 CORS 头
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+
+    // 处理 OPTIONS 请求
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+
+    // 路由处理
+    if (url.startsWith("/viewer/")) {
+      this.handleViewerRequest(url, res);
+    } else if (url.startsWith("/vcd/")) {
+      this.handleVcdFileRequest(url, res);
+    } else if (url.startsWith("/static/")) {
+      this.handleStaticFileRequest(url, res);
+    } else {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+    }
+  }
+
+  /**
+   * 处理查看器页面请求
+   */
+  private handleViewerRequest(url: string, res: http.ServerResponse): void {
+    const match = url.match(/^\/viewer\/(.+)$/);
+    if (!match) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+      return;
+    }
+
+    const fileId = match[1];
+    const filePath = this.vcdFiles.get(fileId);
+
+    if (!filePath) {
+      console.error(`[VCDFileServer] 文件 ID 不存在: ${fileId}`);
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("File Not Found");
+      return;
+    }
+
+    // 生成 HTML 页面
+    const html = this.generateViewerHtml(fileId, filePath);
+    res.writeHead(200, {
+      "Content-Type": "text/html; charset=utf-8",
+      "Content-Length": Buffer.byteLength(html),
+    });
+    res.end(html);
+  }
+
+  /**
+   * 处理 VCD 文件请求
+   */
+  private handleVcdFileRequest(url: string, res: http.ServerResponse): void {
+    const match = url.match(/^\/vcd\/(.+)$/);
+    if (!match) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+      return;
+    }
+
+    const fileId = match[1];
+    const filePath = this.vcdFiles.get(fileId);
+
+    if (!filePath) {
+      console.error(`[VCDFileServer] 文件 ID 不存在: ${fileId}`);
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("File Not Found");
+      return;
+    }
+
+    // 检查文件是否存在
+    if (!fs.existsSync(filePath)) {
+      console.error(`[VCDFileServer] 文件不存在: ${filePath}`);
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("File Not Found");
+      return;
+    }
+
+    // 读取并发送文件
+    try {
+      const fileContent = fs.readFileSync(filePath);
+      res.writeHead(200, {
+        "Content-Type": "text/plain",
+        "Content-Length": fileContent.length,
+      });
+      res.end(fileContent);
+      console.log(`[VCDFileServer] 成功发送文件: ${filePath}`);
+    } catch (error) {
+      console.error(`[VCDFileServer] 读取文件失败:`, error);
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("Internal Server Error");
+    }
+  }
+
+  /**
+   * 处理静态文件请求（Surfer 资源）
+   */
+  private handleStaticFileRequest(url: string, res: http.ServerResponse): void {
+    const match = url.match(/^\/static\/(.+)$/);
+    if (!match) {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found");
+      return;
+    }
+
+    const fileName = match[1];
+    const filePath = path.join(this.extensionUri.fsPath, "media", "surfer", fileName);
+
+    if (!fs.existsSync(filePath)) {
+      console.error(`[VCDFileServer] 静态文件不存在: ${filePath}`);
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("File Not Found");
+      return;
+    }
+
+    try {
+      const fileContent = fs.readFileSync(filePath);
+      const contentType = this.getContentType(fileName);
+      res.writeHead(200, {
+        "Content-Type": contentType,
+        "Content-Length": fileContent.length,
+      });
+      res.end(fileContent);
+    } catch (error) {
+      console.error(`[VCDFileServer] 读取静态文件失败:`, error);
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end("Internal Server Error");
+    }
+  }
+
+  /**
+   * 获取文件的 Content-Type
+   */
+  private getContentType(fileName: string): string {
+    const ext = path.extname(fileName).toLowerCase();
+    const contentTypes: { [key: string]: string } = {
+      ".js": "application/javascript",
+      ".wasm": "application/wasm",
+      ".html": "text/html",
+      ".css": "text/css",
+    };
+    return contentTypes[ext] || "application/octet-stream";
+  }
+
+  /**
+   * 解析 VCD 文件获取根模块及其直接子模块名称
+   */
+  private parseVcdRootScope(vcdFilePath: string): string[] {
+    try {
+      const buffer = fs.readFileSync(vcdFilePath, { encoding: 'utf8' });
+      const lines = buffer.split('\n');
+
+      const scopeNames: string[] = [];
+      let scopeDepth = 0;
+      const scopeStack: string[] = [];
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+
+        if (trimmed.startsWith('$enddefinitions')) {
+          break;
+        }
+
+        const scopeMatch = trimmed.match(/^\$scope\s+(\w+)\s+(\w+)/);
+        if (scopeMatch) {
+          const scopeType = scopeMatch[1];
+          const scopeName = scopeMatch[2];
+
+          if (scopeDepth === 0 && scopeType === 'module') {
+            scopeStack.push(scopeName);
+          } else if (scopeDepth === 1 && scopeType === 'module') {
+            const fullPath = [...scopeStack, scopeName];
+            scopeNames.push(fullPath.join('.'));
+          }
+
+          scopeDepth++;
+        }
+
+        if (trimmed.startsWith('$upscope')) {
+          scopeDepth--;
+          if (scopeDepth === 0) {
+            scopeStack.pop();
+          }
+        }
+      }
+
+      return scopeNames;
+    } catch (error) {
+      console.error("[VCDFileServer] 解析 VCD 文件失败:", error);
+      return [];
+    }
+  }
+
+  /**
+   * 生成波形查看器 HTML 页面
+   */
+  private generateViewerHtml(fileId: string, vcdFilePath: string): string {
+    const vcdUrl = this.getFileUrl(fileId);
+    const fileName = path.basename(vcdFilePath);
+    const scopeNames = this.parseVcdRootScope(vcdFilePath);
+    const scopeNamesJson = JSON.stringify(scopeNames);
+
+    const htmlPart1 = this.getHtmlPart1(fileName);
+    const htmlPart2 = this.getHtmlPart2(vcdUrl, scopeNamesJson);
+    const htmlPart3 = this.getHtmlPart3();
+
+    return htmlPart1 + htmlPart2 + htmlPart3;
+  }
+
+  private getHtmlPart1(fileName: string): string {
+    return `<!DOCTYPE html>
+<html>
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=no">
+    <title>Surfer 波形查看器 - ${fileName}</title>
+    <script>
+        window.surferReady = false;
+        window.pendingVcdData = null;
+
+        function on_surfer_error(msg) {
+            console.log("Surfer error:", msg);
+            document.getElementById("error_message").innerHTML = msg;
+            document.getElementById("error_container").style.display = "block";
+        }
+        window.on_surfer_error = on_surfer_error;
+    </script>
+    <script type="module">
+        console.log('[Browser] 开始初始化 Surfer...');
+        import init from '/static/surfer.js';
+        await init({module_or_path: '/static/surfer_bg.wasm'});
+        console.log('[Browser] Surfer WASM 已加载');
+
+        import {WebHandle, inject_message, id_of_name, draw_text_arrow} from '/static/surfer.js';
+        window.inject_message = inject_message;
+        window.id_of_name = id_of_name;
+        window.draw_text_arrow = draw_text_arrow;
+
+        await new Promise(resolve => setTimeout(resolve, 100));
+        window.surferReady = true;
+        console.log('[Browser] Surfer 已完全初始化并准备就绪');
+
+        try {
+            window.inject_message(JSON.stringify("ToggleLogs"));
+            console.log('[Browser] 已发送关闭日志面板命令');
+        } catch (e) {
+            console.log('[Browser] 关闭日志面板失败:', e);
+        }
+
+        if (window.pendingVcdData) {
+            console.log('[Browser] 发现待处理的 VCD 数据，立即加载');
+            loadVcdUrl(window.pendingVcdData);
+            window.pendingVcdData = null;
+        }
+    </script>`;
+  }
+
+  private getHtmlPart2(vcdUrl: string, scopeNamesJson: string): string {
+    return `
+    <script>
+        function loadVcdUrl(data) {
+            try {
+                console.log('[Browser] ========== 开始加载 VCD URL ==========');
+                console.log('[Browser] URL:', data.url);
+                console.log('[Browser] Scope names from VCD:', data.scopeNames);
+
+                setTimeout(() => {
+                    console.log('[Browser] 通过 postMessage 发送 LoadUrl 命令');
+                    window.postMessage({
+                        command: 'LoadUrl',
+                        url: data.url
+                    }, '*');
+                    console.log('[Browser] ✅ 已发送 LoadUrl 命令');
+
+                    setTimeout(async () => {
+                        try {
+                            console.log('[Browser] 尝试自动添加所有信号');
+                            let scopeNamesToTry = [];
+
+                            if (data.scopeNames && data.scopeNames.length > 0) {
+                                scopeNamesToTry = data.scopeNames.map(path => path.split('.'));
+                                console.log('[Browser] 使用解析的作用域名称:', scopeNamesToTry);
+                            } else {
+                                scopeNamesToTry = [['top'], ['testbench'], ['tb'], ['test'], ['dut']];
+                                console.log('[Browser] 使用回退作用域名称');
+                            }
+
+                            for (let i = 0; i < scopeNamesToTry.length; i++) {
+                                const scopeName = scopeNamesToTry[i];
+                                try {
+                                    const addScopeMsg = {
+                                        "AddScope": [
+                                            {"strs": scopeName, "id": {"Wellen": i + 1}},
+                                            true
+                                        ]
+                                    };
+                                    window.inject_message(JSON.stringify(addScopeMsg));
+                                    console.log('[Browser] 已发送 AddScope: ' + scopeName.join('.'));
+                                } catch (e) {
+                                    console.log('[Browser] AddScope 失败: ' + scopeName.join('.'), e);
+                                }
+                            }
+
+                            setTimeout(() => {
+                                try {
+                                    window.inject_message(JSON.stringify("ZoomToFit"));
+                                    console.log('[Browser] 已发送 ZoomToFit 命令');
+                                } catch (e) {
+                                    console.log('[Browser] ZoomToFit 失败:', e);
+                                }
+                            }, 500);
+                        } catch (e) {
+                            console.error('[Browser] 添加信号失败:', e);
+                        }
+                    }, 1500);
+                }, 100);
+            } catch (error) {
+                console.error('[Browser] ❌ 加载 VCD 失败:', error);
+                on_surfer_error(error.message + '\\n' + error.stack);
+            }
+        }
+        window.loadVcdUrl = loadVcdUrl;
+
+        // 页面加载完成后自动加载 VCD
+        window.addEventListener('load', () => {
+            const vcdData = {
+                url: '${vcdUrl}',
+                scopeNames: ${scopeNamesJson}
+            };
+            if (window.surferReady) {
+                loadVcdUrl(vcdData);
+            } else {
+                window.pendingVcdData = vcdData;
+            }
+        });
+    </script>`;
+  }
+
+  private getHtmlPart3(): string {
+    return `
+    <style>
+        html, body {
+            overflow: hidden;
+            margin: 0 !important;
+            padding: 0 !important;
+            height: 100%;
+            width: 100%;
+            background: #1e1e1e;
+        }
+        canvas {
+            margin-right: auto;
+            margin-left: auto;
+            display: block;
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+        }
+        #error_container {
+            padding: 1em;
+            border-radius: 0.5em;
+            margin: 0px auto;
+            max-width: 980px;
+            color: #f48771;
+            background-color: #5a1d1d;
+            position: relative;
+            height: 90%;
+            overflow: scroll;
+        }
+        #error_message {
+            overflow: scroll;
+            white-space: break-spaces;
+        }
+    </style>
+</head>
+<body>
+    <canvas id="the_canvas_id"></canvas>
+    <div id="error_container" style="display: none;">
+        <h3>❌ Surfer 加载失败</h3>
+        <code id="error_message"></code>
+    </div>
+    <script src="/static/integration.js"></script>
+    <script>
+        register_message_listener();
+    </script>
+</body>
+</html>`;
+  }
+}

src/types/api.ts

@@ -0,0 +1,494 @@
+/**
+ * 后端 API 类型定义
+ * 对应后端 IC Coder Backend 的接口格式
+ */
+
+import { CompactedMemory, CompactedMessage } from "./memory";
+
+// ============== 对话请求/响应 ==============
+
+/**
+ * 运行模式类型
+ * - plan: 只读模式，只能查询分析
+ * - ask: 逐个确认，每个写操作需确认
+ * - agent: 智能体自主（默认）
+ * - auto: 完全自动
+ */
+export type RunMode = "plan" | "ask" | "agent" | "auto";
+
+/**
+ * 服务等级类型
+ * - lite: 轻量级
+ * - syntaxic: 语法级
+ * - max: 最大性能
+ * - auto: 自动选择
+ */
+export type ServiceTier = "lite" | "syntaxic" | "max" | "auto";
+
+/**
+ * 对话请求
+ * POST /api/dialog/stream
+ */
+export interface DialogRequest {
+  /** 任务ID（用于记忆隔离） */
+  taskId: string;
+  /** 用户消息 */
+  message: string;
+  /** 用户ID */
+  userId: string;
+  /** 运行模式 */
+  mode: RunMode;
+  /** 服务等级 */
+  serviceTier?: ServiceTier;
+  /** 压缩后的记忆数据（用于后端重启后恢复） */
+  compactedData?: CompactedMemory;
+  /** 压缩后产生的新消息 */
+  newMessages?: CompactedMessage[];
+  /** 知识图谱数据（JSON 字符串，用于恢复知识图谱） */
+  knowledgeData?: string;
+}
+
+// ============== SSE 事件类型 ==============
+
+/** SSE 事件类型枚举 */
+export type SSEEventType =
+  | "text_delta" // 文本增量
+  | "tool_call" // 客户端工具调用请求
+  | "tool_confirm" // 工具确认请求（Ask 模式）
+  | "plan_confirm" // 计划确认请求（Plan 模式）
+  | "tool_start" // 工具开始执行
+  | "tool_complete" // 工具执行完成
+  | "tool_error" // 工具执行错误
+  | "ask_user" // 向用户提问
+  | "agent_start" // 子智能体启动
+  | "agent_progress" // 子智能体进度
+  | "agent_complete" // 子智能体完成
+  | "agent_error" // 子智能体错误
+  | "memory_compacted" // 记忆压缩完成
+  | "context_usage" // 上下文使用量
+  | "complete" // 对话完成
+  | "error" // 错误
+  | "warning" // 警告
+  | "notification" // 通知
+  | "depth_update" // 深度更新
+  | "heartbeat"; // 心跳
+
+/** text_delta 事件数据 */
+export interface TextDeltaEvent {
+  text: string;
+}
+
+/** tool_start 事件数据 */
+export interface ToolStartEvent {
+  tool_name: string;
+  tool_input: unknown;
+}
+
+/** tool_complete 事件数据 */
+export interface ToolCompleteEvent {
+  tool_name: string;
+  result: string;
+}
+
+/** tool_error 事件数据 */
+export interface ToolErrorEvent {
+  tool_name: string;
+  error: string;
+}
+
+/** tool_confirm 事件数据（Ask 模式确认请求） */
+export interface ToolConfirmEvent {
+  /** 确认ID，用于匹配响应 */
+  confirmId: number;
+  /** 工具名称 */
+  toolName: string;
+  /** 工具输入参数 */
+  toolInput: Record<string, unknown>;
+  /** 时间戳 */
+  timestamp: number;
+}
+
+/** plan_confirm 事件数据（Plan 模式计划确认） */
+export interface PlanConfirmEvent {
+  /** 确认ID */
+  confirmId: number;
+  /** 计划标题 */
+  title: string;
+  /** 执行步骤列表 */
+  steps: string[];
+  /** 计划摘要 */
+  summary: string;
+  /** 时间戳 */
+  timestamp: number;
+}
+
+/** ask_user 事件数据 */
+export interface AskUserEvent {
+  askId: string;
+  question: string;
+  options: string[];
+}
+
+/** complete 事件数据 */
+export interface CompleteEvent {
+  status: string;
+  finish_reason: string;
+}
+
+/** error 事件数据 */
+export interface ErrorEvent {
+  message: string;
+}
+
+/** warning 事件数据 */
+export interface WarningEvent {
+  message: string;
+}
+
+/** notification 事件数据 */
+export interface NotificationEvent {
+  message: string;
+}
+
+/** depth_update 事件数据 */
+export interface DepthUpdateEvent {
+  depth: number;
+}
+
+// ============== 智能体事件类型 ==============
+
+/** agent_start 事件数据 */
+export interface AgentStartEvent {
+  agentId: string;
+  agentType: string;
+  agentName: string;
+  instruction: string;
+  timestamp: number;
+}
+
+/** agent_progress 事件数据 */
+export interface AgentProgressEvent {
+  agentId: string;
+  step: number;
+  toolName: string;
+  toolInput?: unknown;
+  toolResult?: string;
+  status: "running" | "completed" | "error";
+  timestamp: number;
+}
+
+/** agent_complete 事件数据 */
+export interface AgentCompleteEvent {
+  agentId: string;
+  agentType: string;
+  summary: string;
+  stats: Record<string, unknown>;
+  timestamp: number;
+}
+
+/** agent_error 事件数据 */
+export interface AgentErrorEvent {
+  agentId: string;
+  agentType: string;
+  error: string;
+  timestamp: number;
+}
+
+/** context_usage 事件数据 */
+export interface ContextUsageEvent {
+  currentTokens: number;
+  maxTokens: number;
+  percentage: number;
+}
+
+// ============== 工具调用协议 (MCP 格式) ==============
+
+/**
+ * 工具调用请求（MCP格式）
+ * 后端通过 SSE tool_call 事件推送
+ */
+export interface ToolCallRequest {
+  /** JSON-RPC版本，固定为"2.0" */
+  jsonrpc: "2.0";
+  /** 请求ID，用于匹配响应 */
+  id: number;
+  /** 方法名，固定为"tools/call" */
+  method: "tools/call";
+  /** 调用参数 */
+  params: {
+    /** 工具名称 */
+    name: string;
+    /** 工具参数 */
+    arguments: Record<string, unknown>;
+  };
+}
+
+/**
+ * 工具执行结果（MCP格式）
+ * POST /api/tool/result
+ */
+export interface ToolCallResult {
+  /** JSON-RPC版本 */
+  jsonrpc: "2.0";
+  /** 请求ID，与ToolCallRequest.id对应 */
+  id: number;
+  /** 执行结果（与error互斥） */
+  result?: ToolResultContent;
+  /** 错误信息（与result互斥） */
+  error?: ToolResultError;
+}
+
+/** 工具执行结果内容 */
+export interface ToolResultContent {
+  /** 内容列表 */
+  content: ContentItem[];
+  /** 是否为错误结果（业务错误，如编译失败） */
+  isError: boolean;
+}
+
+/** 内容项 */
+export interface ContentItem {
+  /** 内容类型：text, image, resource */
+  type: string;
+  /** 文本内容 */
+  text: string;
+}
+
+/** 工具系统错误 */
+export interface ToolResultError {
+  /** 错误码 */
+  code: number;
+  /** 错误消息 */
+  message: string;
+}
+
+// ============== 用户回答 ==============
+
+/**
+ * 用户回答请求
+ * POST /api/task/answer
+ */
+export interface AnswerRequest {
+  /** 问题ID */
+  askId: string;
+  /** 任务ID */
+  taskId: string;
+  /** 选中的选项列表 */
+  selected?: string[];
+  /** 自定义输入内容 */
+  customInput?: string;
+}
+
+/** 用户回答响应 */
+export interface AnswerResponse {
+  success: boolean;
+  message?: string;
+  error?: string;
+}
+
+// ============== 工具结果响应 ==============
+
+/** 工具结果响应 */
+export interface ToolResultResponse {
+  success: boolean;
+  message?: string;
+  error?: string;
+}
+
+// ============== 工具确认响应 ==============
+
+/**
+ * 工具确认响应请求
+ * POST /api/tool/confirm
+ */
+export interface ToolConfirmResponse {
+  /** 确认ID，与 ToolConfirmEvent.confirmId 对应 */
+  confirmId: number;
+  /** 任务ID */
+  taskId: string;
+  /** 是否批准执行 */
+  approved: boolean;
+}
+
+// ============== 用户信息 ==============
+
+/**
+ * 用户信息响应
+ * GET /system/user/getInfo
+ */
+export interface UserInfoResponse {
+  /** 响应消息 */
+  msg: string;
+  /** 响应代码 (200 表示成功) */
+  code: number;
+  /** 权限列表 */
+  permissions: string[];
+  /** 角色列表 */
+  roles: string[];
+  /** 是否默认修改密码 */
+  isDefaultModifyPwd: boolean;
+  /** 密码是否过期 */
+  isPasswordExpired: boolean;
+  /** 用户信息 */
+  user: {
+    userId: number;
+    userName: string;
+    nickName: string;
+    email?: string;
+    phonenumber?: string;
+    sex?: string;
+    avatar?: string;
+    status?: string;
+    createTime?: string;
+    loginDate?: string;
+    [key: string]: any;
+  };
+}
+
+// ============== 会员信息 ==============
+
+/**
+ * 会员单条记录
+ */
+export interface MembershipItemVO {
+  membershipId: number | null;
+  tierCode: string;
+  tierName: string;
+  tierLevel: number;
+  expireTime: string | null;
+  remainingDays: number;
+  permanent: boolean;
+  nextGrantTime: string | null;
+  lastGrantTime: string | null;
+  grantCycle: number;
+  totalGranted: number;
+  monthlyCredits: number;
+  teamSeat: boolean;
+}
+
+/**
+ * 用户会员信息
+ */
+export interface UserMembershipVO {
+  userId: number;
+  tierCode: string;
+  tierName: string;
+  tierLevel: number;
+  allowedModelCombinations: string[];
+  description?: string;
+  createdTime?: string;
+  updatedTime?: string;
+}
+
+/**
+ * 多会员信息响应
+ */
+export interface MultiMembershipVO extends UserMembershipVO {
+  displayTier?: MembershipItemVO;
+  allMemberships?: MembershipItemVO[];
+  totalMonthlyCredits?: number;
+}
+
+/**
+ * 会员信息响应
+ * GET /strangeloop/api/membership/current
+ */
+export interface MembershipResponse {
+  code: number;
+  msg?: string;
+  message?: string;
+  data?: MultiMembershipVO;
+}
+
+// ============== 辅助类型 ==============
+
+/** 后端工具名称 */
+export type ToolName =
+  | "file_read"
+  | "file_write"
+  | "file_delete"
+  | "file_list"
+  | "syntax_check"
+  | "simulation"
+  | "waveform_summary"
+  | "waveform_trace"
+  | "knowledge_save"
+  | "knowledge_load";
+
+/** file_read 工具参数 */
+export interface FileReadArgs {
+  path: string;
+}
+
+/** file_write 工具参数 */
+export interface FileWriteArgs {
+  path: string;
+  content: string;
+}
+
+/** file_delete 工具参数 */
+export interface FileDeleteArgs {
+  /** 要删除的文件路径 */
+  path: string;
+}
+
+/** file_list 工具参数 */
+export interface FileListArgs {
+  path?: string;
+  extension?: string;
+}
+
+/** syntax_check 工具参数 */
+export interface SyntaxCheckArgs {
+  code: string;
+}
+
+/** simulation 工具参数 */
+export interface SimulationArgs {
+  rtlPath: string;
+  tbPath: string;
+  duration?: string;
+}
+
+/** waveform_summary 工具参数 */
+export interface WaveformSummaryArgs {
+  vcdPath: string;
+  signals: string;
+  checkpoints?: string;
+}
+
+/** waveform_trace 工具参数 */
+export interface WaveformTraceArgs {
+  /** Verilog 源文件路径（相对于项目根目录） */
+  verilogPath: string;
+  /** VCD 波形文件路径（相对于项目根目录） */
+  vcdPath: string;
+  /** 仿真工具的输出字符串（包含 mismatch 信息） */
+  simOutput: string;
+  /** BFS 回溯层数，默认 2 */
+  traceLevel?: number;
+}
+
+/** knowledge_save 工具参数 */
+export interface KnowledgeSaveArgs {
+  /** 知识图谱 JSON 数据 */
+  data: string;
+}
+
+/** knowledge_load 工具参数 */
+export interface KnowledgeLoadArgs {
+  // 无参数，直接读取 .iccoder/knowledge.json
+}
+
+/** 工具参数联合类型 */
+export type ToolArgs =
+  | FileReadArgs
+  | FileWriteArgs
+  | FileDeleteArgs
+  | FileListArgs
+  | SyntaxCheckArgs
+  | SimulationArgs
+  | WaveformSummaryArgs
+  | WaveformTraceArgs
+  | KnowledgeSaveArgs
+  | KnowledgeLoadArgs;

src/types/chatHistory.ts

@@ -5,7 +5,8 @@ export enum MessageType {
   SYSTEM = "SYSTEM",
   USER = "USER",
   AI = "AI",
-  TOOL_EXECUTION_RESULT = "TOOL_EXECUTION_RESULT"
+  TOOL_EXECUTION_RESULT = "TOOL_EXECUTION_RESULT",
+  COMPACTION_SUMMARY = "COMPACTION_SUMMARY"  // 压缩摘要
 }
 
 /**
@@ -56,6 +57,7 @@ export interface AiMessage extends BaseMessage {
   text?: string;
   toolExecutionRequests?: ToolExecutionRequest[];
   thinking?: string;
+  segments?: any[]; // 保存完整的 segments 信息用于还原显示
 }
 
 /**
@@ -68,10 +70,22 @@ export interface ToolExecutionResultMessage extends BaseMessage {
   text: string; // JSON字符串
 }
 
+/**
+ * 压缩摘要消息
+ */
+export interface CompactionSummaryMessage extends BaseMessage {
+  type: MessageType.COMPACTION_SUMMARY;
+  summary: string;
+  version: number;
+  compactedAt: string;
+  originalMessageCount: number;
+  compactedMessageCount: number;
+}
+
 /**
  * 联合消息类型
  */
-export type ChatMessage = SystemMessage | UserMessage | AiMessage | ToolExecutionResultMessage;
+export type ChatMessage = SystemMessage | UserMessage | AiMessage | ToolExecutionResultMessage | CompactionSummaryMessage;
 
 /**
  * 对话轮次元数据

src/types/memory.ts

@@ -0,0 +1,42 @@
+/**
+ * 压缩记忆相关类型定义
+ */
+
+/**
+ * 压缩后的记忆数据
+ */
+export interface CompactedMemory {
+  taskId: string;
+  version: number;
+  compactedAt: string;
+  summary: string;
+  recentMessages: CompactedMessage[];
+  originalMessageCount: number;
+  compactedMessageCount: number;
+}
+
+/**
+ * 压缩消息格式
+ */
+export interface CompactedMessage {
+  type: 'USER' | 'AI' | 'SYSTEM' | 'TOOL_RESULT';
+  content: string;
+  toolCall?: ToolCallInfo;
+}
+
+/**
+ * 工具调用信息
+ */
+export interface ToolCallInfo {
+  toolName: string;
+  toolInput: string;
+  toolOutput?: string;
+}
+
+/**
+ * 记忆压缩 SSE 事件
+ */
+export interface MemoryCompactedEvent {
+  taskId: string;
+  compactedData: CompactedMemory;
+}

src/utils/chatHistoryManager.ts

@@ -8,8 +8,11 @@ import {
   MessageType,
   UserMessage,
   AiMessage,
-  SystemMessage
+  SystemMessage,
+  ToolExecutionResultMessage,
+  CompactionSummaryMessage
 } from '../types/chatHistory';
+import { CompactedMemory, CompactedMessage } from '../types/memory';
 
 /**
  * 会话历史管理器
@@ -20,6 +23,10 @@ export class ChatHistoryManager {
   private baseDir: string; // ~/.iccoder
   private currentTaskId: string | null = null;
   private currentProjectPath: string | null = null;
+  // 存储每个面板的任务信息（taskId 和 projectPath）
+  private panelTaskMap: Map<string, { taskId: string; projectPath: string }> = new Map();
+  // 追踪压缩后产生的新消息
+  private newMessagesSinceCompaction: CompactedMessage[] = [];
 
   private constructor() {
     // 设置存储路径: ~/.iccoder
@@ -33,12 +40,13 @@ export class ChatHistoryManager {
    * 规则：
    * - 替换 \ 和 / 为 --
    * - 替换 : 为空
-   * 例如：C:\Users\admin\Documents\Project -> C--Users-admin-Documents-Project
+   * 例如：C:\Users\admin\Documents\Project -> C--Users--admin--Documents--Project
    */
   private encodeProjectPath(projectPath: string): string {
     return projectPath
-      .replace(/:/g, '') // 移除冒号
+      .replace(/\\/g, '--') // 替换反斜杠为 --
-      .replace(/[/\\]/g, '--'); // 替换斜杠为 --
+      .replace(/\//g, '--') // 替换正斜杠为 --
+      .replace(/:/g, ''); // 移除冒号
   }
 
   /**
@@ -107,6 +115,43 @@ export class ChatHistoryManager {
     return ChatHistoryManager.instance;
   }
 
+  /**
+   * 为面板设置任务ID
+   */
+  public setPanelTask(panelId: string, taskId: string, projectPath: string): void {
+    this.panelTaskMap.set(panelId, { taskId, projectPath });
+    this.currentTaskId = taskId;
+    this.currentProjectPath = projectPath;
+  }
+
+  /**
+   * 获取面板的任务ID
+   */
+  public getPanelTask(panelId: string): string | null {
+    const taskInfo = this.panelTaskMap.get(panelId);
+    return taskInfo ? taskInfo.taskId : null;
+  }
+
+  /**
+   * 切换到指定面板的任务上下文
+   */
+  public switchToPanelTask(panelId: string): boolean {
+    const taskInfo = this.panelTaskMap.get(panelId);
+    if (taskInfo) {
+      this.currentTaskId = taskInfo.taskId;
+      this.currentProjectPath = taskInfo.projectPath;
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * 移除面板的任务映射
+   */
+  public removePanelTask(panelId: string): void {
+    this.panelTaskMap.delete(panelId);
+  }
+
   /**
    * 创建新任务
    */
@@ -264,17 +309,11 @@ export class ChatHistoryManager {
   }
 
   /**
-   * 确保有当前任务，如果没有则自动创建
+   * 确保有当前任务，如果没有则抛出错误
    */
   private async ensureCurrentTask(): Promise<void> {
     if (!this.currentTaskId || !this.currentProjectPath) {
-      // 获取当前工作区路径
+      throw new Error("没有当前任务上下文，请确保已正确初始化面板任务");
-      const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath;
-      if (workspacePath) {
-        await this.createTask(workspacePath, "默认任务");
-      } else {
-        throw new Error("没有打开的工作区，无法创建任务");
-      }
     }
   }
 
@@ -300,14 +339,15 @@ export class ChatHistoryManager {
   /**
    * 添加AI消息
    */
-  public async addAiMessage(text: string, toolRequests?: any[]): Promise<void> {
+  public async addAiMessage(text: string, toolRequests?: any[], segments?: any[]): Promise<void> {
     await this.ensureCurrentTask();
     const messages = await this.loadConversation();
 
     const aiMessage: AiMessage = {
       type: MessageType.AI,
       text,
-      toolExecutionRequests: toolRequests
+      toolExecutionRequests: toolRequests,
+      segments // 保存完整的 segments 信息
     };
 
     messages.push(aiMessage);
@@ -333,6 +373,24 @@ export class ChatHistoryManager {
     await this.saveConversation(messages);
   }
 
+  /**
+   * 添加工具执行结果消息
+   */
+  public async addToolExecutionResult(id: string, toolName: string, result: string): Promise<void> {
+    await this.ensureCurrentTask();
+    const messages = await this.loadConversation();
+
+    const toolResultMessage: ToolExecutionResultMessage = {
+      type: MessageType.TOOL_EXECUTION_RESULT,
+      id,
+      toolName,
+      text: result
+    };
+
+    messages.push(toolResultMessage);
+    await this.saveConversation(messages);
+  }
+
   /**
    * 记录对话轮次元数据
    */
@@ -450,6 +508,20 @@ export class ChatHistoryManager {
             tasks.push(JSON.parse(data));
           } catch (error) {
             console.error(`加载任务 ${taskId} 失败:`, error);
+            // 跳过无效的任务目录
+            // 尝试清理空目录
+            try {
+              const taskDirUri = vscode.Uri.file(path.join(projectDir, taskId));
+              const taskDirEntries = await vscode.workspace.fs.readDirectory(taskDirUri);
+              if (taskDirEntries.length === 0) {
+                // 目录为空，删除它
+                await vscode.workspace.fs.delete(taskDirUri, { recursive: false });
+                console.log(`已清理空任务目录: ${taskId}`);
+              }
+            } catch (cleanupError) {
+              // 清理失败，忽略错误
+              console.warn(`清理任务目录 ${taskId} 失败:`, cleanupError);
+            }
           }
         }
       }
@@ -494,4 +566,331 @@ export class ChatHistoryManager {
   public getBaseDir(): string {
     return this.baseDir;
   }
+
+  /**
+   * 加载指定任务的会话内容
+   * @param projectPath 项目路径
+   * @param taskId 任务ID
+   * @returns 任务会话内容，如果任务不存在则返回null
+   */
+  public async loadTaskSession(projectPath: string, taskId: string): Promise<TaskSession | null> {
+    const taskDir = this.getTaskDir(projectPath, taskId);
+    const metaPath = path.join(taskDir, 'meta.json');
+
+    try {
+      // 检查任务是否存在
+      const metaUri = vscode.Uri.file(metaPath);
+      const metaContent = await vscode.workspace.fs.readFile(metaUri);
+      const meta: TaskMeta = JSON.parse(Buffer.from(metaContent).toString('utf-8'));
+
+      // 读取会话内容
+      const conversationPath = path.join(taskDir, 'conversation.json');
+      let messages: ChatMessage[] = [];
+      try {
+        const conversationUri = vscode.Uri.file(conversationPath);
+        const conversationContent = await vscode.workspace.fs.readFile(conversationUri);
+        messages = JSON.parse(Buffer.from(conversationContent).toString('utf-8'));
+      } catch {
+        // 会话文件不存在，使用空数组
+      }
+
+      // 读取会话元数据
+      const conversationMetaPath = path.join(taskDir, 'conversation_meta.jsonl');
+      let conversationMeta: ConversationMeta[] = [];
+      try {
+        const metaUri = vscode.Uri.file(conversationMetaPath);
+        const content = await vscode.workspace.fs.readFile(metaUri);
+        const data = Buffer.from(content).toString('utf-8');
+        conversationMeta = data
+          .split('\n')
+          .filter(line => line.trim())
+          .map(line => JSON.parse(line));
+      } catch {
+        // 元数据文件不存在，使用空数组
+      }
+
+      return {
+        meta,
+        messages,
+        conversationMeta
+      };
+    } catch (error) {
+      console.error(`加载任务 ${taskId} 的会话失败:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * 获取会话历史列表（支持分页）
+   * 返回格式：{ id: taskId, title: 第一句用户消息, timestamp: 创建时间 }
+   * @param projectPath 项目路径
+   * @param offset 偏移量（从第几条开始，默认0）
+   * @param limit 每页数量（默认10条）
+   * @returns { items: 历史列表, total: 总数, hasMore: 是否还有更多 }
+   */
+  public async getConversationHistoryList(
+    projectPath: string,
+    offset: number = 0,
+    limit: number = 10
+  ): Promise<{
+    items: Array<{ id: string; title: string; timestamp: string }>;
+    total: number;
+    hasMore: boolean;
+  }> {
+    const tasks = await this.listProjectTasks(projectPath);
+    const total = tasks.length;
+    const historyList: Array<{ id: string; title: string; timestamp: string }> = [];
+
+    // 计算分页范围
+    const start = offset;
+    const end = Math.min(offset + limit, total);
+    const limitedTasks = tasks.slice(start, end);
+
+    for (const task of limitedTasks) {
+      // 读取该任务的 conversation.json 获取第一句用户消息
+      const taskDir = this.getTaskDir(task.projectPath, task.taskId);
+      const conversationPath = path.join(taskDir, 'conversation.json');
+
+      try {
+        const uri = vscode.Uri.file(conversationPath);
+        const content = await vscode.workspace.fs.readFile(uri);
+        const data = Buffer.from(content).toString('utf-8');
+        const messages: ChatMessage[] = JSON.parse(data);
+
+        // 找到第一条用户消息
+        const firstUserMessage = messages.find(msg => msg.type === MessageType.USER) as UserMessage | undefined;
+
+        let title = '未命名会话';
+        if (firstUserMessage && firstUserMessage.contents && firstUserMessage.contents.length > 0) {
+          const textContent = firstUserMessage.contents.find(c => c.type === 'TEXT');
+          if (textContent && 'text' in textContent) {
+            // 截取前50个字符作为标题
+            title = textContent.text.length > 50
+              ? textContent.text.substring(0, 50) + '...'
+              : textContent.text;
+          }
+        }
+
+        historyList.push({
+          id: task.taskId,
+          title,
+          timestamp: task.createdAt
+        });
+      } catch (error) {
+        console.error(`读取任务 ${task.taskId} 的会话历史失败:`, error);
+        // 如果读取失败，使用任务名称作为标题
+        historyList.push({
+          id: task.taskId,
+          title: task.taskName || '未命名会话',
+          timestamp: task.createdAt
+        });
+      }
+    }
+
+    // 返回分页结果
+    return {
+      items: historyList,
+      total,
+      hasMore: end < total
+    };
+  }
+
+  // ========== 压缩数据相关方法 ==========
+
+  /**
+   * 保存压缩数据（存入 conversation.json 作为压缩摘要消息）
+   */
+  public async saveCompactedData(compacted: CompactedMemory): Promise<void> {
+    // 尝试从多个来源获取 projectPath
+    let projectPath = this.currentProjectPath;
+
+    if (!projectPath) {
+      for (const [, taskInfo] of this.panelTaskMap) {
+        if (taskInfo.taskId === compacted.taskId) {
+          projectPath = taskInfo.projectPath;
+          break;
+        }
+      }
+    }
+
+    if (!projectPath) {
+      console.error('[ChatHistoryManager] 无法保存压缩数据：projectPath 为空');
+      return;
+    }
+
+    // 读取现有对话历史
+    const taskDir = this.getTaskDir(projectPath, compacted.taskId);
+    const conversationPath = path.join(taskDir, 'conversation.json');
+    let messages: ChatMessage[] = [];
+
+    try {
+      const uri = vscode.Uri.file(conversationPath);
+      const content = await vscode.workspace.fs.readFile(uri);
+      messages = JSON.parse(Buffer.from(content).toString('utf-8'));
+    } catch {
+      // 文件不存在，使用空数组
+    }
+
+    // 创建压缩摘要消息
+    const summaryMessage: CompactionSummaryMessage = {
+      type: MessageType.COMPACTION_SUMMARY,
+      summary: compacted.summary,
+      version: compacted.version,
+      compactedAt: compacted.compactedAt,
+      originalMessageCount: compacted.originalMessageCount,
+      compactedMessageCount: compacted.compactedMessageCount
+    };
+
+    // 添加到对话历史
+    messages.push(summaryMessage);
+
+    // 保存
+    const uri = vscode.Uri.file(conversationPath);
+    const content = Buffer.from(JSON.stringify(messages, null, 2), 'utf-8');
+    await vscode.workspace.fs.writeFile(uri, content);
+
+    // 重置新消息追踪
+    this.newMessagesSinceCompaction = [];
+
+    console.log(`[ChatHistoryManager] 压缩摘要已保存到 conversation.json: taskId=${compacted.taskId}`);
+  }
+
+  /**
+   * 加载压缩数据（从 conversation.json 构建）
+   */
+  public async loadCompactedData(taskId: string): Promise<CompactedMemory | null> {
+    // 尝试从多个来源获取 projectPath
+    let projectPath = this.currentProjectPath;
+
+    if (!projectPath) {
+      for (const [, taskInfo] of this.panelTaskMap) {
+        if (taskInfo.taskId === taskId) {
+          projectPath = taskInfo.projectPath;
+          break;
+        }
+      }
+    }
+
+    if (!projectPath) {
+      console.log('[ChatHistoryManager] loadCompactedData: projectPath 为空');
+      return null;
+    }
+
+    // 读取 conversation.json
+    const taskDir = this.getTaskDir(projectPath, taskId);
+    const conversationPath = path.join(taskDir, 'conversation.json');
+
+    try {
+      const uri = vscode.Uri.file(conversationPath);
+      const content = await vscode.workspace.fs.readFile(uri);
+      const messages: ChatMessage[] = JSON.parse(Buffer.from(content).toString('utf-8'));
+
+      if (messages.length === 0) {
+        console.log('[ChatHistoryManager] conversation.json 为空');
+        return null;
+      }
+
+      // 从 conversation.json 构建 CompactedMemory
+      return this.buildCompactedMemoryFromConversation(taskId, messages);
+    } catch {
+      console.log('[ChatHistoryManager] conversation.json 不存在:', conversationPath);
+      return null;
+    }
+  }
+
+  /**
+   * 从 conversation.json 构建 CompactedMemory
+   */
+  private buildCompactedMemoryFromConversation(taskId: string, messages: ChatMessage[]): CompactedMemory {
+    // 查找最后一个压缩摘要消息
+    let lastSummary: CompactionSummaryMessage | null = null;
+    let summaryIndex = -1;
+
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].type === MessageType.COMPACTION_SUMMARY) {
+        lastSummary = messages[i] as CompactionSummaryMessage;
+        summaryIndex = i;
+        break;
+      }
+    }
+
+    // 获取摘要后的消息（或全部消息）
+    const recentMessages = summaryIndex >= 0
+      ? messages.slice(summaryIndex + 1)
+      : messages;
+
+    // 转换为 CompactedMessage 格式
+    const compactedMessages: CompactedMessage[] = recentMessages.map(msg => ({
+      type: this.mapMessageType(msg.type),
+      content: this.extractMessageContent(msg)
+    }));
+
+    return {
+      taskId,
+      version: lastSummary?.version || Date.now(),
+      compactedAt: lastSummary?.compactedAt || new Date().toISOString(),
+      summary: lastSummary?.summary || '',
+      recentMessages: compactedMessages,
+      originalMessageCount: messages.length,
+      compactedMessageCount: compactedMessages.length
+    };
+  }
+
+  /**
+   * 映射消息类型
+   */
+  private mapMessageType(type: MessageType): 'USER' | 'AI' | 'SYSTEM' | 'TOOL_RESULT' {
+    switch (type) {
+      case MessageType.USER: return 'USER';
+      case MessageType.AI: return 'AI';
+      case MessageType.SYSTEM: return 'SYSTEM';
+      case MessageType.TOOL_EXECUTION_RESULT: return 'TOOL_RESULT';
+      default: return 'USER';
+    }
+  }
+
+  /**
+   * 提取消息内容
+   */
+  private extractMessageContent(msg: ChatMessage): string {
+    switch (msg.type) {
+      case MessageType.USER:
+        return (msg as UserMessage).contents?.[0]?.text || '';
+      case MessageType.AI:
+        return (msg as AiMessage).text || '';
+      case MessageType.SYSTEM:
+        return (msg as SystemMessage).text || '';
+      case MessageType.TOOL_EXECUTION_RESULT:
+        return (msg as ToolExecutionResultMessage).text || '';
+      default:
+        return '';
+    }
+  }
+
+  /**
+   * 获取压缩后产生的新消息
+   */
+  public getNewMessagesSinceCompaction(): CompactedMessage[] {
+    return this.newMessagesSinceCompaction;
+  }
+
+  /**
+   * 追踪新消息（用户消息）
+   */
+  public trackUserMessage(text: string): void {
+    this.newMessagesSinceCompaction.push({
+      type: 'USER',
+      content: text
+    });
+  }
+
+  /**
+   * 追踪新消息（AI消息）
+   */
+  public trackAiMessage(text: string): void {
+    this.newMessagesSinceCompaction.push({
+      type: 'AI',
+      content: text
+    });
+  }
 }

src/utils/createFiles.ts

@@ -16,7 +16,9 @@ export async function createFile(
       if (workspaceFolders && workspaceFolders.length > 0) {
         absolutePath = path.join(workspaceFolders[0].uri.fsPath, filePath);
       } else {
-        throw new Error("没有打开的工作区，无法创建相对路径的文件");
+        throw new Error(
+          "请先打开一个文件夹作为工作区，这样我就能为您创建文件了"
+        );
       }
     }
 
@@ -28,7 +30,7 @@ export async function createFile(
       throw new Error(`文件已存在: ${absolutePath}`);
     } catch (error: any) {
       // 如果文件不存在，继续创建
-      if (error.code !== 'FileNotFound') {
+      if (error.code !== "FileNotFound") {
         throw error;
       }
     }
@@ -65,7 +67,9 @@ export async function createOrOverwriteFile(
       if (workspaceFolders && workspaceFolders.length > 0) {
         absolutePath = path.join(workspaceFolders[0].uri.fsPath, filePath);
       } else {
-        throw new Error("没有打开的工作区，无法创建相对路径的文件");
+        throw new Error(
+          "请先打开一个文件夹作为工作区，这样我就能为您创建文件了"
+        );
       }
     }
 
@@ -99,7 +103,9 @@ export async function createDirectory(dirPath: string): Promise<void> {
       if (workspaceFolders && workspaceFolders.length > 0) {
         absolutePath = path.join(workspaceFolders[0].uri.fsPath, dirPath);
       } else {
-        throw new Error("没有打开的工作区，无法创建相对路径的目录");
+        throw new Error(
+          "请先打开一个文件夹作为工作区，这样我就能为您创建目录了"
+        );
       }
     }
 
@@ -115,7 +121,7 @@ export async function createDirectory(dirPath: string): Promise<void> {
       }
     } catch (error: any) {
       // 如果目录不存在，继续创建
-      if (error.code !== 'FileNotFound') {
+      if (error.code !== "FileNotFound") {
         throw error;
       }
     }
@@ -161,7 +167,9 @@ export async function deleteFile(filePath: string): Promise<void> {
       if (workspaceFolders && workspaceFolders.length > 0) {
         absolutePath = path.join(workspaceFolders[0].uri.fsPath, filePath);
       } else {
-        throw new Error("没有打开的工作区，无法删除相对路径的文件");
+        throw new Error(
+          "请先打开一个文件夹作为工作区，这样我就能为您删除文件了"
+        );
       }
     }
 
@@ -197,7 +205,9 @@ export async function updateFile(
       if (workspaceFolders && workspaceFolders.length > 0) {
         absolutePath = path.join(workspaceFolders[0].uri.fsPath, filePath);
       } else {
-        throw new Error("没有打开的工作区，无法修改相对路径的文件");
+        throw new Error(
+          "请先打开一个文件夹作为工作区，这样我就能为您修改文件了"
+        );
       }
     }
 
@@ -236,7 +246,9 @@ export async function appendToFile(
       if (workspaceFolders && workspaceFolders.length > 0) {
         absolutePath = path.join(workspaceFolders[0].uri.fsPath, filePath);
       } else {
-        throw new Error("没有打开的工作区，无法追加相对路径的文件");
+        throw new Error(
+          "请先打开一个文件夹作为工作区，这样我就能为您追加文件内容了"
+        );
       }
     }
 
@@ -274,7 +286,9 @@ export async function replaceFile(
       if (workspaceFolders && workspaceFolders.length > 0) {
         absolutePath = path.join(workspaceFolders[0].uri.fsPath, filePath);
       } else {
-        throw new Error("没有打开的工作区，无法修改相对路径的文件");
+        throw new Error(
+          "请先打开一个文件夹作为工作区，这样我就能为您修改文件了"
+        );
       }
     }
 
@@ -291,14 +305,17 @@ export async function replaceFile(
 
     // 转义特殊字符，将字符串作为字面量处理
     const escapeRegExp = (str: string) => {
-      return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
     };
 
     // 替换内容 - 如果是字符串，先转义特殊字符
     let newContent: string;
-    if (typeof searchValue === 'string') {
+    if (typeof searchValue === "string") {
       const escapedSearch = escapeRegExp(searchValue);
-      newContent = fileContent.replace(new RegExp(escapedSearch, "g"), replaceValue);
+      newContent = fileContent.replace(
+        new RegExp(escapedSearch, "g"),
+        replaceValue
+      );
     } else {
       newContent = fileContent.replace(searchValue, replaceValue);
     }
@@ -330,7 +347,9 @@ export async function insertAtLine(
       if (workspaceFolders && workspaceFolders.length > 0) {
         absolutePath = path.join(workspaceFolders[0].uri.fsPath, filePath);
       } else {
-        throw new Error("没有打开的工作区，无法修改相对路径的文件");
+        throw new Error(
+          "请先打开一个文件夹作为工作区，这样我就能为您修改文件了"
+        );
       }
     }
 
@@ -382,7 +401,9 @@ export async function renameFile(
         absoluteNewPath = path.join(workspaceRoot, newPath);
       }
     } else {
-      throw new Error("没有打开的工作区,无法重命名相对路径的文件");
+      throw new Error(
+        "请先打开一个文件夹作为工作区，这样我就能为您重命名文件了"
+      );
     }
 
     const oldUri = vscode.Uri.file(absoluteOldPath);
@@ -401,10 +422,13 @@ export async function renameFile(
       throw new Error(`目标文件已存在: ${absoluteNewPath}`);
     } catch (error: any) {
       // 如果文件不存在，继续重命名
-      if (error.code !== 'FileNotFound' && !error.message.includes('目标文件已存在')) {
+      if (
+        error.code !== "FileNotFound" &&
+        !error.message.includes("目标文件已存在")
+      ) {
         throw error;
       }
-      if (error.message.includes('目标文件已存在')) {
+      if (error.message.includes("目标文件已存在")) {
         throw error;
       }
     }

src/utils/messageHandler.ts

@@ -15,6 +15,41 @@ import {
   checkIverilogAvailable,
 } from "./iverilogRunner";
 import { ChatHistoryManager } from "./chatHistoryManager";
+import { dialogManager, DialogSession } from "../services/dialogService";
+import { userInteractionManager } from "../services/userInteraction";
+import { healthCheck } from "../services/apiClient";
+
+import type { RunMode, ServiceTier } from "../types/api";
+
+/** 是否使用后端服务（可通过配置控制） */
+let useBackendService = true;
+
+/** 当前对话会话 */
+let currentSession: DialogSession | null = null;
+
+/** 最后一个活跃的 taskId（用于压缩等操作） */
+let lastTaskId: string | null = null;
+
+/** 待执行的计划（Plan 模式确认后自动执行） */
+let pendingPlanExecution: {
+  panel: vscode.WebviewPanel;
+  planTitle: string;
+  extensionPath: string;
+  taskId: string; // 保存 taskId 以便复用
+} | null = null;
+
+/**
+ * 设置待执行的计划（由 ICHelperPanel 调用）
+ */
+export function setPendingPlanExecution(
+  panel: vscode.WebviewPanel,
+  planTitle: string,
+  extensionPath: string,
+  taskId: string
+): void {
+  pendingPlanExecution = { panel, planTitle, extensionPath, taskId };
+  console.log("[MessageHandler] 设置待执行计划:", planTitle, "taskId:", taskId);
+}
 
 /**
  * 处理用户消息
@@ -22,44 +57,383 @@ import { ChatHistoryManager } from "./chatHistoryManager";
 export async function handleUserMessage(
   panel: vscode.WebviewPanel,
   text: string,
-  extensionPath?: string
+  extensionPath?: string,
+  mode?: RunMode,
+  serviceTier?: ServiceTier // 新增：服务等级参数
 ) {
   console.log("收到用户消息:", text);
 
-  // 记录用户消息到历史
+  // 记录用户消息到历史（允许失败，不阻塞主流程）
-  const historyManager = ChatHistoryManager.getInstance();
+  try {
-  await historyManager.addUserMessage(text);
+    const historyManager = ChatHistoryManager.getInstance();
+    await historyManager.addUserMessage(text);
+  } catch (error) {
+    console.warn("记录消息历史失败（可能没有打开工作区）:", error);
+  }
 
-  // 检查是否是 VCD 生成命令
+  // 设置 WebView 面板用于用户交互
+  userInteractionManager.setWebviewPanel(panel);
+
+  // 检查是否是 VCD 生成命令（本地处理）
   if (isVCDGenerationCommand(text)) {
     await handleVCDGeneration(panel, extensionPath || "");
     return;
   }
 
-  // 检查是否是文件操作命令
+  // 检查是否是文件操作命令（本地处理）
   const fileOperation = parseFileOperation(text);
-
-  console.log("解析结果:", fileOperation);
-
   if (fileOperation) {
     console.log("执行文件操作:", fileOperation.type, fileOperation.filePath);
     await handleFileOperation(panel, fileOperation);
     return;
   }
 
-  // 普通消息处理
+  // 尝试使用后端服务
-  console.log("作为普通消息处理");
+  if (useBackendService && extensionPath) {
-  const reply = getMockReply(text);
+    try {
+      await handleUserMessageWithBackend(
+        panel,
+        text,
+        extensionPath,
+        mode,
+        undefined,
+        serviceTier
+      );
+      return;
+    } catch (error) {
+      console.error("后端服务不可用:", error);
+      panel.webview.postMessage({
+        command: "updateStatus",
+        text: "后端服务不可用",
+        type: "error",
+      });
+      // 恢复输入状态
+      panel.webview.postMessage({
+        command: "updateSegments",
+        segments: [],
+        isComplete: true,
+      });
+      throw error;
+    }
+  }
 
-  // 记录助手回复到历史
+  // 如果没有 extensionPath，显示错误
-  await historyManager.addAiMessage(reply);
+  panel.webview.postMessage({
+    command: "updateStatus",
+    text: "无法处理消息：缺少必要参数",
+    type: "error",
+  });
+}
 
-  setTimeout(() => {
+/**
-    panel.webview.postMessage({
+ * 使用后端服务处理用户消息
-      command: "receiveMessage",
+ */
-      text: reply,
+async function handleUserMessageWithBackend(
-    });
+  panel: vscode.WebviewPanel,
-  }, 500);
+  text: string,
+  extensionPath: string,
+  mode?: RunMode,
+  reuseTaskId?: string, // 可选，复用现有 taskId（用于 Plan 模式确认后继续执行）
+  serviceTier?: ServiceTier // 新增：服务等级参数
+): Promise<void> {
+  const historyManager = ChatHistoryManager.getInstance();
+
+  // 获取 historyManager 中的 taskId（由 ICHelperPanel 创建）
+  // 优先使用 reuseTaskId，其次使用 historyManager 的 taskId
+  const taskIdToUse = reuseTaskId || historyManager.getCurrentTaskId();
+
+  // 创建或复用会话
+  if (!currentSession || !currentSession.active) {
+    currentSession = dialogManager.createSession(
+      extensionPath,
+      taskIdToUse || undefined
+    );
+    // 保存 taskId 用于后续操作（如压缩）
+    lastTaskId = currentSession.getTaskId();
+    console.log(
+      "[MessageHandler] 创建会话: taskId=",
+      lastTaskId,
+      "来源=",
+      taskIdToUse ? "historyManager" : "新生成"
+    );
+  }
+
+  // 显示状态栏
+  panel.webview.postMessage({
+    command: "updateStatus",
+    text: "思考中...",
+    type: "thinking",
+  });
+
+  return new Promise((resolve, reject) => {
+    currentSession!.sendMessage(
+      text,
+      {
+        onText: (fullText, isStreaming) => {
+          // 不再单独处理文本，统一通过 onSegmentUpdate 处理
+        },
+
+        onSegmentUpdate: (segments) => {
+          // 实时发送段落更新，按后端返回顺序展示
+          panel.webview.postMessage({
+            command: "updateSegments",
+            segments: segments,
+          });
+        },
+
+        onToolStart: (toolName) => {
+          // 更新状态栏
+          panel.webview.postMessage({
+            command: "updateStatus",
+            text: `正在执行 ${toolName}...`,
+            type: "working",
+          });
+        },
+
+        onToolComplete: (toolName, result) => {
+          // 工具完成，不需要单独处理，通过 onSegmentUpdate 统一更新
+        },
+
+        onToolError: (toolName, error) => {
+          // 工具错误，不需要单独处理，通过 onSegmentUpdate 统一更新
+        },
+
+        onQuestion: (askId, question, options) => {
+          // 只更新状态栏，问题显示由 onSegmentUpdate 统一处理
+          panel.webview.postMessage({
+            command: "updateStatus",
+            text: "等待用户回答...",
+            type: "working",
+          });
+        },
+
+        onComplete: async (segments) => {
+          // 隐藏状态栏
+          panel.webview.postMessage({
+            command: "hideStatus",
+          });
+
+          // 最后一次发送完整的段落
+          console.log("[MessageHandler] 对话完成, 段落数:", segments.length);
+
+          const result = await panel.webview.postMessage({
+            command: "updateSegments",
+            segments: segments,
+            isComplete: true,
+          });
+          console.log("[MessageHandler] postMessage 返回值:", result);
+
+          // 保存完整的 segments 到历史记录
+          try {
+            // 将完整的 segments 保存到一条 AI 消息中
+            // 这样加载时可以完整还原对话样式
+            const textContent = segments
+              .filter((s) => s.type === "text" && s.content)
+              .map((s) => s.content)
+              .join("\n");
+
+            await historyManager.addAiMessage(textContent, undefined, segments);
+          } catch (error) {
+            console.warn("保存AI响应历史失败:", error);
+          }
+
+          // 检查是否有待执行的计划（Plan 模式确认后自动执行）
+          if (pendingPlanExecution) {
+            const {
+              panel: execPanel,
+              planTitle,
+              extensionPath: execPath,
+              taskId: reuseTaskId,
+            } = pendingPlanExecution;
+            pendingPlanExecution = null;
+            console.log(
+              "[MessageHandler] 自动执行计划:",
+              planTitle,
+              "复用 taskId:",
+              reuseTaskId
+            );
+
+            // 延迟一小段时间确保当前对话完全结束
+            setTimeout(async () => {
+              try {
+                // 复用 taskId 创建新会话，确保知识图谱数据不丢失
+                await handleUserMessageWithBackend(
+                  execPanel,
+                  `请按照刚才的计划执行：${planTitle}`,
+                  execPath,
+                  "agent",
+                  reuseTaskId // 复用 Plan 模式的 taskId
+                );
+              } catch (err) {
+                console.error("[MessageHandler] 自动执行计划失败:", err);
+              }
+            }, 500);
+          }
+
+          resolve();
+        },
+
+        onError: (message) => {
+          panel.webview.postMessage({
+            command: "hideLoading",
+          });
+          panel.webview.postMessage({
+            command: "receiveMessage",
+            text: `❌ 错误: ${message}`,
+          });
+          // 恢复输入状态
+          panel.webview.postMessage({
+            command: "updateSegments",
+            segments: [],
+            isComplete: true,
+          });
+          reject(new Error(message));
+        },
+
+        onNotification: (message) => {
+          vscode.window.showInformationMessage(message);
+        },
+
+        onContextUsage: (data) => {
+          // 发送上下文使用量到 WebView
+          panel.webview.postMessage({
+            command: "contextUsage",
+            currentTokens: data.currentTokens,
+            maxTokens: data.maxTokens,
+            percentage: data.percentage,
+          });
+        },
+      },
+      mode,
+      serviceTier // 传递服务等级
+    );
+  });
+}
+
+/**
+ * 处理用户回答（从 WebView 调用）
+ */
+export async function handleUserAnswer(
+  askId: string,
+  selected?: string[],
+  customInput?: string
+): Promise<void> {
+  if (currentSession) {
+    await currentSession.submitAnswer(askId, selected, customInput);
+  }
+}
+
+/**
+ * 中止当前对话
+ */
+export async function abortCurrentDialog(): Promise<void> {
+  if (currentSession) {
+    // 保存当前已有的对话内容
+    const segments = currentSession.getSegments();
+    if (segments && segments.length > 0) {
+      try {
+        const historyManager = ChatHistoryManager.getInstance();
+        const textContent = segments
+          .filter((s) => s.type === "text" && s.content)
+          .map((s) => s.content)
+          .join("\n");
+
+        // 添加中止标记
+        const abortedContent = textContent + "\n\n[对话已被用户中止]";
+        await historyManager.addAiMessage(abortedContent, undefined, segments);
+        console.log("[MessageHandler] 已保存中止前的对话内容");
+      } catch (error) {
+        console.warn("[MessageHandler] 保存中止对话失败:", error);
+      }
+    }
+  }
+
+  // 通知 WebView 重置分段消息容器
+  const panel = userInteractionManager.getWebviewPanel();
+  if (panel) {
+    panel.webview.postMessage({ command: "resetSegmentedMessage" });
+    console.log("[MessageHandler] 已发送重置分段消息命令");
+  }
+
+  dialogManager.abortCurrentSession();
+  currentSession = null;
+}
+
+/**
+ * 获取当前会话的 taskId
+ */
+export function getCurrentTaskId(): string | null {
+  return currentSession?.getTaskId() || lastTaskId;
+}
+
+/**
+ * 设置最后的 taskId（加载历史会话时调用）
+ */
+export function setLastTaskId(taskId: string): void {
+  lastTaskId = taskId;
+  console.log("[MessageHandler] 设置 lastTaskId:", taskId);
+}
+
+/**
+ * 处理计划操作（Plan 模式）
+ * @param panel WebView 面板
+ * @param action 操作类型：confirm/modify/cancel
+ * @param planTitle 计划标题
+ * @param extensionPath 扩展路径
+ */
+export async function handlePlanAction(
+  panel: vscode.WebviewPanel,
+  action: string,
+  planTitle: string,
+  extensionPath: string
+): Promise<void> {
+  console.log("[handlePlanAction] action:", action, "planTitle:", planTitle);
+
+  switch (action) {
+    case "confirm":
+      // 确认执行：切换到 Agent 模式并发送执行消息
+      panel.webview.postMessage({
+        command: "switchMode",
+        mode: "agent",
+      });
+      // 发送执行消息
+      await handleUserMessage(
+        panel,
+        `请按照刚才的计划执行：${planTitle}`,
+        extensionPath,
+        "agent"
+      );
+      break;
+
+    case "modify":
+      // 修改计划：提示用户输入修改建议
+      const modification = await vscode.window.showInputBox({
+        prompt: "请输入您对计划的修改建议",
+        placeHolder: "例如：第2步需要先检查文件是否存在...",
+        ignoreFocusOut: true,
+      });
+      if (modification) {
+        await handleUserMessage(
+          panel,
+          `请根据以下建议修改计划：${modification}`,
+          extensionPath,
+          "plan"
+        );
+      }
+      break;
+
+    case "cancel":
+      // 取消计划：通知用户
+      panel.webview.postMessage({
+        command: "addMessage",
+        text: "计划已取消。",
+        sender: "bot",
+      });
+      break;
+
+    default:
+      console.warn("[handlePlanAction] 未知操作:", action);
+  }
 }
 
 /**
@@ -97,7 +471,9 @@ function parseFileOperation(text: string): {
   }
 
   // 匹配重命名文件：将 xxx.ts 重命名为 yyy.ts 或 把 xxx.ts 改名为 yyy.ts（优先匹配，避免被修改匹配）
-  const renameMatch = lowerText.match(/(?:将|把)\s*(.+?\.\w+)\s*(?:重命名|改名)\s*(?:为|成)\s*(.+?\.\w+)/);
+  const renameMatch = lowerText.match(
+    /(?:将|把)\s*(.+?\.\w+)\s*(?:重命名|改名)\s*(?:为|成)\s*(.+?\.\w+)/
+  );
   if (renameMatch) {
     const oldPath = renameMatch[1].trim();
     const newPath = renameMatch[2].trim();
@@ -112,7 +488,9 @@ function parseFileOperation(text: string): {
   // 格式1: 在 xxx.ts 中将 "aaa" 替换为 "bbb"
   // 格式2: 将 xxx.ts 文件 "aaa" 替换为 "bbb"
   // 格式3: 将 xxx.ts 文件 'aaa' 替换为 'bbb'
-  const replaceMatch1 = lowerText.match(/在\s*(.+?\.\w+)\s*(?:文件)?中?\s*(?:将|把)\s*["'](.+?)["']\s*替换\s*(?:为|成)\s*["'](.+?)["']/);
+  const replaceMatch1 = lowerText.match(
+    /在\s*(.+?\.\w+)\s*(?:文件)?中?\s*(?:将|把)\s*["'](.+?)["']\s*替换\s*(?:为|成)\s*["'](.+?)["']/
+  );
   if (replaceMatch1) {
     const filePath = replaceMatch1[1].trim();
     const searchText = replaceMatch1[2].trim();
@@ -126,7 +504,9 @@ function parseFileOperation(text: string): {
   }
 
   // 格式2: 将 xxx.ts 文件 "aaa" 替换为 "bbb"
-  const replaceMatch2 = lowerText.match(/(?:将|把)\s*(.+?\.\w+)\s*(?:文件)?\s*["'](.+?)["']\s*替换\s*(?:为|成)\s*["'](.+?)["']/);
+  const replaceMatch2 = lowerText.match(
+    /(?:将|把)\s*(.+?\.\w+)\s*(?:文件)?\s*["'](.+?)["']\s*替换\s*(?:为|成)\s*["'](.+?)["']/
+  );
   if (replaceMatch2) {
     const filePath = replaceMatch2[1].trim();
     const searchText = replaceMatch2[2].trim();
@@ -454,41 +834,6 @@ export async function handleReplaceInFile(
   }
 }
 
-/**
- * 获取模拟回复
- */
-function getMockReply(question: string): string {
-  const replies = [
-    `已收到您的问题："${question}"
-
-这是一个演示版本，实际需要连接AI服务。
-
-示例回复：这是一个计数器模板：
-\`\`\`verilog
-module counter (
-  input clk,
-  input rst_n,
-  output reg [3:0] count
-);
-  always @(posedge clk or negedge rst_n) begin
-    if (!rst_n) count <= 0;
-    else count <= count + 1;
-  end
-endmodule
-\`\`\``,
-
-    `感谢提问！关于"${question}"，在真实版本中我会：
-1. 分析您的代码上下文
-2. 提供优化建议
-3. 生成完整代码
-4. 解释设计原理
-
-当前是演示版，请点击侧边栏按钮快速生成代码。`,
-  ];
-
-  return replies[Math.floor(Math.random() * replies.length)];
-}
-
 /**
  * 将代码插入到编辑器
  */
@@ -581,7 +926,8 @@ async function handleVCDGeneration(
 
         if (!projectCheck.hasTestbench) {
           errorMsg += "• ❌ 缺少 testbench 文件\n";
-          errorMsg += "\n提示: testbench 文件应包含 $dumpfile 和 $dumpvars 语句来生成 VCD 文件。\n";
+          errorMsg +=
+            "\n提示: testbench 文件应包含 $dumpfile 和 $dumpvars 语句来生成 VCD 文件。\n";
         } else {
           errorMsg += `• ✅ Testbench: ${projectCheck.testbenchFile}\n`;
         }
@@ -625,9 +971,7 @@ async function handleVCDGeneration(
           fileName: fileName,
         });
 
-        vscode.window.showInformationMessage(
+        vscode.window.showInformationMessage(`VCD 文件生成成功: ${fileName}`);
-          `VCD 文件生成成功: ${fileName}`
-        );
       } else {
         panel.webview.postMessage({
           command: "receiveMessage",

src/utils/readFiles.ts

@@ -94,6 +94,13 @@ export async function readDirectory(
     const results = [];
 
     for (const [fileName, fileType] of entries) {
+      // 处理目录
+      if (fileType === vscode.FileType.Directory) {
+        results.push({ path: fileName + '/', content: '[目录]', isDirectory: true });
+        continue;
+      }
+
+      // 处理文件
       if (fileType === vscode.FileType.File) {
         // 如果指定了扩展名过滤
         if (extensions && extensions.length > 0) {
@@ -108,7 +115,7 @@ export async function readDirectory(
           const fileUri = vscode.Uri.file(filePath);
           const contentBytes = await vscode.workspace.fs.readFile(fileUri);
           const content = Buffer.from(contentBytes).toString("utf-8");
-          results.push({ path: fileName, content });
+          results.push({ path: fileName, content, isDirectory: false });
         } catch (error) {
           // 跳过无法读取的文件
           continue;

src/utils/vcdParser.ts

@@ -0,0 +1,467 @@
+/**
+ * VCD (Value Change Dump) 解析器
+ * 纯 TypeScript 实现，参照 VerilogCoder 项目格式
+ *
+ * @deprecated 当前未使用，保留备用
+ * 目前使用 waveformTracer.ts 调用 Python 打包的 waveform_trace.exe
+ * 未来可能用此文件替换 Python 实现
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ==================== 类型定义 ====================
+
+/** 信号定义 */
+export interface VcdSignal {
+  name: string;           // 完整路径名，如 "tb.top_module.data"
+  shortName: string;      // 短名，如 "data"
+  symbolId: string;       // VCD 符号 ID，如 "!", "#"
+  width: number;          // 位宽
+  varType: string;        // 变量类型：wire, reg
+  module: string;         // 所属模块
+}
+
+/** 时间-值对 */
+export interface TimeValue {
+  time: number;
+  value: string;
+}
+
+/** 信号波形数据 */
+export interface SignalWaveform {
+  signal: VcdSignal;
+  changes: TimeValue[];
+}
+
+/** VCD 解析结果 */
+export interface VcdData {
+  date?: string;
+  version?: string;
+  timescale: string;
+  endTime: number;
+  signals: Map<string, VcdSignal>;      // symbolId -> signal
+  waveforms: Map<string, TimeValue[]>;  // symbolId -> changes
+}
+
+/** Mismatch 信息 */
+export interface MismatchInfo {
+  time: number;
+  signal: string;
+  dutValue: string;
+  refValue: string;
+}
+
+// ==================== VCD 解析器 ====================
+
+export class VcdParser {
+  private signals: Map<string, VcdSignal> = new Map();
+  private waveforms: Map<string, TimeValue[]> = new Map();
+  private scopeStack: string[] = [];
+  private timescale: string = '1ns';
+  private currentTime: number = 0;
+  private endTime: number = 0;
+  private date?: string;
+  private version?: string;
+
+  /**
+   * 解析 VCD 文件
+   */
+  parse(filePath: string): VcdData {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return this.parseContent(content);
+  }
+
+  /**
+   * 解析 VCD 内容
+   */
+  parseContent(content: string): VcdData {
+    // 预处理：将多行指令合并成单行
+    const normalizedContent = this.normalizeVcdContent(content);
+    const lines = normalizedContent.split('\n');
+    let inDefinitions = true;
+
+    for (const rawLine of lines) {
+      const line = rawLine.trim();
+      if (!line) continue;
+
+      if (inDefinitions) {
+        // 解析定义区
+        if (line.startsWith('$enddefinitions')) {
+          inDefinitions = false;
+          continue;
+        }
+        this.parseDefinition(line);
+      } else {
+        // 解析数据区
+        this.parseValueChange(line);
+      }
+    }
+
+    return {
+      date: this.date,
+      version: this.version,
+      timescale: this.timescale,
+      endTime: this.endTime,
+      signals: this.signals,
+      waveforms: this.waveforms
+    };
+  }
+
+  private parseDefinition(line: string): void {
+    if (line.startsWith('$date')) {
+      this.date = this.extractValue(line);
+    } else if (line.startsWith('$version')) {
+      this.version = this.extractValue(line);
+    } else if (line.startsWith('$timescale')) {
+      this.timescale = this.extractValue(line) || '1ns';
+    } else if (line.startsWith('$scope')) {
+      const match = line.match(/\$scope\s+\w+\s+(\S+)/);
+      if (match) {
+        this.scopeStack.push(match[1]);
+      }
+    } else if (line.startsWith('$upscope')) {
+      this.scopeStack.pop();
+    } else if (line.startsWith('$var')) {
+      this.parseVariable(line);
+    }
+  }
+
+  private parseVariable(line: string): void {
+    // $var wire 8 # data [7:0] $end
+    // $var reg 1 ! clk $end
+    const match = line.match(/\$var\s+(\w+)\s+(\d+)\s+(\S+)\s+(\S+)/);
+    if (!match) return;
+
+    const [, varType, widthStr, symbolId, name] = match;
+    const width = parseInt(widthStr, 10);
+    const module = this.scopeStack.join('.');
+    const fullName = module ? `${module}.${name}` : name;
+
+    const signal: VcdSignal = {
+      name: fullName,
+      shortName: name.replace(/\[\d+:\d+\]/, ''),  // 移除位宽标注
+      symbolId,
+      width,
+      varType,
+      module
+    };
+
+    this.signals.set(symbolId, signal);
+    this.waveforms.set(symbolId, []);
+  }
+
+  private parseValueChange(line: string): void {
+    if (line.startsWith('#')) {
+      // 时间戳: #100
+      this.currentTime = parseInt(line.substring(1), 10);
+      this.endTime = Math.max(this.endTime, this.currentTime);
+    } else if (line.startsWith('b') || line.startsWith('B')) {
+      // 多位值: b10101010 #
+      const spaceIdx = line.indexOf(' ');
+      if (spaceIdx > 0) {
+        const value = line.substring(1, spaceIdx);
+        const symbolId = line.substring(spaceIdx + 1).trim();
+        this.addChange(symbolId, value);
+      }
+    } else if (line.length >= 2 && !line.startsWith('$')) {
+      // 单位值: 0! 或 1# 或 x$
+      const value = line[0];
+      const symbolId = line.substring(1).trim();
+      if (symbolId && this.signals.has(symbolId)) {
+        this.addChange(symbolId, value);
+      }
+    }
+  }
+
+  private addChange(symbolId: string, value: string): void {
+    const changes = this.waveforms.get(symbolId);
+    if (changes) {
+      changes.push({ time: this.currentTime, value });
+    }
+  }
+
+  private extractValue(line: string): string {
+    // 提取 $xxx value $end 中的 value
+    const match = line.match(/\$\w+\s+(.+?)\s*\$end/);
+    return match ? match[1].trim() : '';
+  }
+
+  /**
+   * 预处理 VCD 内容，将多行指令合并成单行
+   */
+  private normalizeVcdContent(content: string): string {
+    // 将多行 $xxx ... $end 合并成单行
+    return content.replace(/(\$\w+)\s*\n\s*([^\$]+?)\s*\n\s*(\$end)/g, '$1 $2 $3');
+  }
+}
+
+// ==================== 波形分析工具 ====================
+
+/**
+ * 二进制字符串转十六进制
+ */
+export function binaryToHex(binary: string): string {
+  if (binary === 'x' || binary === 'X' || binary.includes('x')) {
+    return 'xx';
+  }
+  if (binary === 'z' || binary === 'Z' || binary.includes('z')) {
+    return 'zz';
+  }
+  if (binary.length <= 1) {
+    return binary;
+  }
+  // 补齐到 4 的倍数
+  const padded = binary.padStart(Math.ceil(binary.length / 4) * 4, '0');
+  let hex = '';
+  for (let i = 0; i < padded.length; i += 4) {
+    hex += parseInt(padded.substring(i, i + 4), 2).toString(16);
+  }
+  return hex;
+}
+
+/**
+ * 获取信号在指定时间的值
+ */
+export function getValueAtTime(
+  changes: TimeValue[],
+  time: number
+): string {
+  let value = 'x';
+  for (const change of changes) {
+    if (change.time <= time) {
+      value = change.value;
+    } else {
+      break;
+    }
+  }
+  return value;
+}
+
+/**
+ * 查找 DUT 和 REF 信号的第一个 mismatch
+ */
+export function findFirstMismatch(
+  vcdData: VcdData,
+  dutSignals: string[],
+  refSignals: string[]
+): MismatchInfo | null {
+  // 收集所有时间点
+  const allTimes = new Set<number>();
+  for (const changes of vcdData.waveforms.values()) {
+    for (const c of changes) {
+      allTimes.add(c.time);
+    }
+  }
+  const sortedTimes = Array.from(allTimes).sort((a, b) => a - b);
+
+  // 按信号名匹配 DUT 和 REF
+  for (const time of sortedTimes) {
+    for (let i = 0; i < dutSignals.length; i++) {
+      const dutSig = findSignalByName(vcdData, dutSignals[i]);
+      const refSig = findSignalByName(vcdData, refSignals[i]);
+
+      if (!dutSig || !refSig) continue;
+
+      const dutChanges = vcdData.waveforms.get(dutSig.symbolId) || [];
+      const refChanges = vcdData.waveforms.get(refSig.symbolId) || [];
+
+      const dutVal = getValueAtTime(dutChanges, time);
+      const refVal = getValueAtTime(refChanges, time);
+
+      // 跳过未知值
+      if (dutVal.includes('x') || refVal.includes('x')) continue;
+
+      if (dutVal !== refVal) {
+        return {
+          time,
+          signal: dutSig.shortName,
+          dutValue: binaryToHex(dutVal),
+          refValue: binaryToHex(refVal)
+        };
+      }
+    }
+  }
+  return null;
+}
+
+/**
+ * 按名称查找信号
+ */
+function findSignalByName(vcdData: VcdData, name: string): VcdSignal | null {
+  for (const signal of vcdData.signals.values()) {
+    if (signal.name.endsWith(name) || signal.shortName === name) {
+      return signal;
+    }
+  }
+  return null;
+}
+
+/**
+ * 生成波形表格（参照 VerilogCoder 格式）
+ */
+export function generateWaveformTable(
+  vcdData: VcdData,
+  signalNames: string[],
+  startTime: number = 0,
+  endTime?: number,
+  windowSize: number = 20
+): string {
+  const actualEndTime = endTime ?? vcdData.endTime;
+
+  // 查找信号
+  const signals: VcdSignal[] = [];
+  for (const name of signalNames) {
+    const sig = findSignalByName(vcdData, name);
+    if (sig) signals.push(sig);
+  }
+
+  if (signals.length === 0) {
+    return '未找到指定信号';
+  }
+
+  // 收集时间点
+  const times = new Set<number>();
+  for (const sig of signals) {
+    const changes = vcdData.waveforms.get(sig.symbolId) || [];
+    for (const c of changes) {
+      if (c.time >= startTime && c.time <= actualEndTime) {
+        times.add(c.time);
+      }
+    }
+  }
+
+  let sortedTimes = Array.from(times).sort((a, b) => a - b);
+  if (sortedTimes.length > windowSize) {
+    sortedTimes = sortedTimes.slice(0, windowSize);
+  }
+
+  // 生成表头
+  const headers = ['time(ns)', ...signals.map(s => s.shortName)];
+  const colWidths = headers.map(h => Math.max(h.length, 8));
+
+  let table = '### Waveform Trace ###\n';
+  table += headers.map((h, i) => h.padEnd(colWidths[i])).join('  ') + '\n';
+  table += colWidths.map(w => '─'.repeat(w)).join('──') + '\n';
+
+  // 生成数据行
+  for (const time of sortedTimes) {
+    const row = [time.toString()];
+    for (const sig of signals) {
+      const changes = vcdData.waveforms.get(sig.symbolId) || [];
+      const val = getValueAtTime(changes, time);
+      row.push(binaryToHex(val));
+    }
+    table += row.map((v, i) => v.padEnd(colWidths[i])).join('  ') + '\n';
+  }
+
+  table += '### Waveform Trace End ###\n';
+  return table;
+}
+
+/**
+ * 获取信号显示名称（模块.信号名[位宽]）
+ */
+function getSignalDisplayName(sig: VcdSignal): string {
+  const moduleParts = sig.module.split('.');
+  const moduleShort = moduleParts[moduleParts.length - 1] || '';
+  const bitInfo = sig.width > 1 ? `[${sig.width - 1}:0]` : '';
+  return moduleShort ? `${moduleShort}.${sig.shortName}${bitInfo}` : `${sig.shortName}${bitInfo}`;
+}
+
+/**
+ * 生成变化日志格式（只记录信号变化）
+ */
+export function generateChangeLog(vcdData: VcdData): string {
+  // 筛选信号（排除 parameter）
+  const signals: VcdSignal[] = [];
+  for (const sig of vcdData.signals.values()) {
+    if (sig.varType !== 'parameter') {
+      signals.push(sig);
+    }
+  }
+
+  // 收集所有时间点
+  const times = new Set<number>();
+  for (const sig of signals) {
+    const changes = vcdData.waveforms.get(sig.symbolId) || [];
+    for (const c of changes) {
+      times.add(c.time);
+    }
+  }
+  const sortedTimes = Array.from(times).sort((a, b) => a - b);
+
+  // 记录每个信号的上一个值
+  const lastValues = new Map<string, string | null>();
+  for (const sig of signals) {
+    lastValues.set(sig.symbolId, null);
+  }
+
+  let log = '';
+
+  for (const time of sortedTimes) {
+    const changes: string[] = [];
+
+    for (const sig of signals) {
+      const waveform = vcdData.waveforms.get(sig.symbolId) || [];
+      const currentVal = binaryToHex(getValueAtTime(waveform, time));
+      const lastVal = lastValues.get(sig.symbolId);
+
+      if (lastVal === null) {
+        changes.push(`${getSignalDisplayName(sig)}=${currentVal}`);
+      } else if (currentVal !== lastVal) {
+        changes.push(`${getSignalDisplayName(sig)} ${lastVal}→${currentVal}`);
+      }
+
+      lastValues.set(sig.symbolId, currentVal);
+    }
+
+    if (changes.length > 0) {
+      log += `#${time}: ${changes.join(', ')}\n`;
+    }
+  }
+
+  return log;
+}
+
+/**
+ * 分析 VCD 文件（主入口）
+ */
+export function analyzeVcdFile(
+  filePath: string,
+  signalFilter?: string,
+  checkpoint?: number
+): string {
+  // 解析 VCD
+  const parser = new VcdParser();
+  const vcdData = parser.parse(filePath);
+
+  // 解析信号过滤器
+  const signalNames = signalFilter
+    ? signalFilter.split(',').map(s => s.trim())
+    : Array.from(vcdData.signals.values()).map(s => s.shortName);
+
+  // 生成摘要
+  let result = `=== VCD 波形分析 ===\n`;
+  result += `文件: ${path.basename(filePath)}\n`;
+  result += `时间单位: ${vcdData.timescale}\n`;
+  result += `仿真时长: 0 - ${vcdData.endTime}${vcdData.timescale}\n\n`;
+
+  // 信号列表
+  result += `--- 信号列表 (${vcdData.signals.size} 个) ---\n`;
+  let idx = 1;
+  for (const sig of vcdData.signals.values()) {
+    if (idx <= 10) {
+      result += `${idx}. ${sig.shortName} (${sig.width}-bit, ${sig.varType})\n`;
+    }
+    idx++;
+  }
+  if (vcdData.signals.size > 10) {
+    result += `... 还有 ${vcdData.signals.size - 10} 个信号\n`;
+  }
+  result += '\n';
+
+  // 变化日志
+  result += generateChangeLog(vcdData);
+
+  return result;
+}

src/utils/waveformTracer.ts

@@ -0,0 +1,145 @@
+/**
+ * 波形追踪工具
+ * 调用 PyInstaller 打包的 waveform_trace 可执行文件
+ */
+import { spawn } from 'child_process';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as vscode from 'vscode';
+
+/**
+ * 波形追踪参数
+ */
+export interface WaveformTraceArgs {
+  /** Verilog 源文件路径（相对于项目根目录） */
+  verilogPath: string;
+  /** VCD 波形文件路径（相对于项目根目录） */
+  vcdPath: string;
+  /** 仿真工具的输出字符串（包含 mismatch 信息） */
+  simOutput: string;
+  /** BFS 回溯层数，默认 2 */
+  traceLevel?: number;
+}
+
+/**
+ * 执行波形追踪
+ * @param args 追踪参数
+ * @param context 执行上下文
+ * @returns 追踪结果字符串
+ */
+export async function executeWaveformTrace(
+  args: WaveformTraceArgs,
+  context: { extensionPath: string }
+): Promise<string> {
+  // 获取可执行文件路径
+  const tracerPath = getWaveformTracerPath(context.extensionPath);
+
+  // 检查可执行文件是否存在
+  if (!fs.existsSync(tracerPath)) {
+    throw new Error(
+      `waveform_trace 工具未安装: ${tracerPath}\n` +
+      '请确保插件包含 tools/waveform_trace/bin/ 目录'
+    );
+  }
+
+  // 获取工作区路径
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  if (!workspaceFolders || workspaceFolders.length === 0) {
+    throw new Error('请先打开一个工作区');
+  }
+  const workspacePath = workspaceFolders[0].uri.fsPath;
+
+  // 解析路径（支持相对路径）
+  const verilogAbsPath = path.isAbsolute(args.verilogPath)
+    ? args.verilogPath
+    : path.join(workspacePath, args.verilogPath);
+  const vcdAbsPath = path.isAbsolute(args.vcdPath)
+    ? args.vcdPath
+    : path.join(workspacePath, args.vcdPath);
+
+  // 验证文件存在
+  if (!fs.existsSync(verilogAbsPath)) {
+    throw new Error(`Verilog 文件不存在: ${args.verilogPath}`);
+  }
+  if (!fs.existsSync(vcdAbsPath)) {
+    throw new Error(`VCD 文件不存在: ${args.vcdPath}`);
+  }
+
+  // 调用可执行文件
+  return new Promise((resolve, reject) => {
+    const child = spawn(tracerPath, [
+      '--verilog', verilogAbsPath,
+      '--vcd', vcdAbsPath,
+      '--sim-output', args.simOutput,
+      '--trace-level', String(args.traceLevel || 2),
+      '--output-format', 'text'
+    ], {
+      windowsHide: true,
+      cwd: workspacePath,
+      shell: false
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data: Buffer) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code: number | null) => {
+      if (code === 0) {
+        resolve(stdout);
+      } else {
+        reject(new Error(
+          `waveform_trace 执行失败 (code=${code}):\n${stderr || stdout}`
+        ));
+      }
+    });
+
+    child.on('error', (error: Error) => {
+      reject(new Error(`waveform_trace 启动失败: ${error.message}`));
+    });
+  });
+}
+
+/**
+ * 获取 waveform_trace 可执行文件路径
+ */
+function getWaveformTracerPath(extensionPath: string): string {
+  const platform = process.platform;
+  let binName = 'waveform_trace';
+
+  if (platform === 'win32') {
+    binName = 'waveform_trace.exe';
+  }
+
+  return path.join(extensionPath, 'tools', 'waveform_trace', 'bin', binName);
+}
+
+/**
+ * 检查 waveform_trace 工具是否可用
+ */
+export function checkWaveformTraceAvailable(extensionPath: string): {
+  available: boolean;
+  message: string;
+  path?: string;
+} {
+  const tracerPath = getWaveformTracerPath(extensionPath);
+
+  if (fs.existsSync(tracerPath)) {
+    return {
+      available: true,
+      message: 'waveform_trace 工具可用',
+      path: tracerPath
+    };
+  } else {
+    return {
+      available: false,
+      message: `waveform_trace 工具未找到: ${tracerPath}`
+    };
+  }
+}

src/views/ICViewProvider.ts

@@ -5,12 +5,17 @@ import {
   insertCodeToEditor,
   handleReadFile,
   handleCreateFile,
+  handleUpdateFile,
+  handleRenameFile,
+  handleReplaceInFile,
+  handleUserAnswer,
+  abortCurrentDialog,
 } from "../utils/messageHandler";
 
 /**
  * 创建并显示IC 侧边栏视图
  */
-export function showICHelperPanel(content: vscode.ExtensionContext) {
+export function showICHelperPanel(context: vscode.ExtensionContext) {
   // 创建WebView面板
   const panel = vscode.window.createWebviewPanel(
     "icCoder", // 面板ID
@@ -19,34 +24,72 @@ export function showICHelperPanel(content: vscode.ExtensionContext) {
     {
       enableScripts: true,
       retainContextWhenHidden: true,
-      localResourceRoots: [vscode.Uri.joinPath(content.extensionUri, "media")],
+      localResourceRoots: [
+        vscode.Uri.joinPath(context.extensionUri, "media"),
+        vscode.Uri.joinPath(context.extensionUri, "src", "assets")
+      ],
     }
   );
 
   // 设置标签页图标
   panel.iconPath = vscode.Uri.joinPath(
-    content.extensionUri,
+    context.extensionUri,
     "media",
-    "图案（方底）.png"
+    "icon.png"
   );
 
   // 获取页面内图标URI
   const iconUri = panel.webview.asWebviewUri(
-    vscode.Uri.joinPath(content.extensionUri, "media", "图案（方底）.png")
+    vscode.Uri.joinPath(context.extensionUri, "media", "icon.png")
   );
+
+  // 获取模型图标URI
+  const autoIconUri = panel.webview.asWebviewUri(
+    vscode.Uri.joinPath(context.extensionUri, "src", "assets", "model", "Auto.png")
+  );
+  const liteIconUri = panel.webview.asWebviewUri(
+    vscode.Uri.joinPath(context.extensionUri, "src", "assets", "model", "lite.png")
+  );
+  const syIconUri = panel.webview.asWebviewUri(
+    vscode.Uri.joinPath(context.extensionUri, "src", "assets", "model", "Sy.png")
+  );
+  const maxIconUri = panel.webview.asWebviewUri(
+    vscode.Uri.joinPath(context.extensionUri, "src", "assets", "model", "Max.png")
+  );
+
   // 设置HTML内容
-  panel.webview.html = getWebviewContent(iconUri.toString());
+  panel.webview.html = getWebviewContent(
+    iconUri.toString(),
+    autoIconUri.toString(),
+    liteIconUri.toString(),
+    syIconUri.toString(),
+    maxIconUri.toString()
+  );
 
   // 处理消息
   panel.webview.onDidReceiveMessage(
     (message) => {
       switch (message.command) {
         case "sendMessage":
-          handleUserMessage(panel, message.text);
+          handleUserMessage(panel, message.text, context.extensionPath, message.mode);
           break;
         case "readFile":
           handleReadFile(panel, message.filePath);
           break;
+        case "updateFile":
+          handleUpdateFile(panel, message.filePath, message.content);
+          break;
+        case "renameFile":
+          handleRenameFile(panel, message.oldPath, message.newPath);
+          break;
+        case "replaceInFile":
+          handleReplaceInFile(
+            panel,
+            message.filePath,
+            message.searchText,
+            message.replaceText
+          );
+          break;
         case "insertCode":
           insertCodeToEditor(message.code);
           break;
@@ -61,10 +104,22 @@ export function showICHelperPanel(content: vscode.ExtensionContext) {
         case "showInfo":
           vscode.window.showInformationMessage(message.text);
           break;
+        // 新增：处理用户回答
+        case "submitAnswer":
+          handleUserAnswer(
+            message.askId,
+            message.selected,
+            message.customInput
+          );
+          break;
+        // 新增：中止对话
+        case "abortDialog":
+          void abortCurrentDialog();
+          break;
       }
     },
     undefined,
-    content.subscriptions
+    context.subscriptions
   );
 }
 
@@ -72,7 +127,23 @@ export function showICHelperPanel(content: vscode.ExtensionContext) {
  * 侧边栏视图提供者
  */
 export class ICViewProvider implements vscode.WebviewViewProvider {
-  constructor(private readonly extensionUri: vscode.Uri) {}
+  constructor(
+    private readonly extensionUri: vscode.Uri,
+    private readonly context: vscode.ExtensionContext
+  ) {}
+
+  /**
+   * 检查登录状态（使用 Authentication API）
+   */
+  private async checkLoginStatus(): Promise<boolean> {
+    try {
+      const session = await vscode.authentication.getSession("iccoder", [], { createIfNone: false });
+      return !!session;
+    } catch (error) {
+      console.log("检查登录状态失败:", error);
+      return false;
+    }
+  }
 
   resolveWebviewView(webviewView: vscode.WebviewView) {
     webviewView.webview.options = {
@@ -80,19 +151,34 @@ export class ICViewProvider implements vscode.WebviewViewProvider {
       localResourceRoots: [vscode.Uri.joinPath(this.extensionUri, "media")],
     };
 
-    webviewView.webview.html = this.getWebviewContent(webviewView.webview);
+    // 检查是否已登录（使用 Authentication API）
+    this.checkLoginStatus().then((isLoggedIn) => {
+      webviewView.webview.html = this.getWebviewContent(
+        webviewView.webview,
+        isLoggedIn
+      );
+    });
 
     // 处理侧边栏的消息
-    webviewView.webview.onDidReceiveMessage((message) => {
+    webviewView.webview.onDidReceiveMessage(
-      if (message.command === "openChat") {
+      (message) => {
-        vscode.commands.executeCommand("ic-coder.openChat");
+        if (message.command === "openChat") {
-      }
+          vscode.commands.executeCommand("ic-coder.openChat");
-    });
+        } else if (message.command === "login") {
+          vscode.commands.executeCommand("ic-coder.login");
+        }
+      },
+      undefined,
+      this.context.subscriptions
+    );
   }
 
-  private getWebviewContent(webview: vscode.Webview): string {
+  private getWebviewContent(
+    webview: vscode.Webview,
+    isLoggedIn: boolean
+  ): string {
     const logoUri = webview.asWebviewUri(
-      vscode.Uri.joinPath(this.extensionUri, "media", "ICCoder主页标志.png")
+      vscode.Uri.joinPath(this.extensionUri, "media", "icon.png")
     );
 
     return `
@@ -153,7 +239,11 @@ export class ICViewProvider implements vscode.WebviewViewProvider {
         <div class="container">
           <img src="${logoUri}" alt="IC Coder" width="120" />
           <h2>欢迎使用 IC Coder</h2>
-          <button class="btn" onclick="openChat()">开始创作</button>
+          ${
+            isLoggedIn
+              ? '<button class="btn" onclick="openChat()">开始创作</button>'
+              : '<button class="btn" onclick="login()">登录账户</button>'
+          }
         </div>
 
         <script>
@@ -163,6 +253,11 @@ export class ICViewProvider implements vscode.WebviewViewProvider {
             vscode.postMessage({ command: 'openChat' });
           }
 
+          // 登录功能
+          function login() {
+            vscode.postMessage({ command: 'login' });
+          }
+
           function generateCode(type) {
             const code = getCodeTemplate(type);
             vscode.postMessage({

src/views/agentCard.ts

@@ -0,0 +1,204 @@
+/**
+ * 智能体卡片组件
+ *
+ * 功能说明:
+ * - 提供智能体执行状态的可视化展示
+ * - 显示智能体名称、状态和执行步骤
+ * - 支持实时更新步骤信息
+ */
+
+import { agentIconSvg } from "../constants/toolIcons";
+
+/**
+ * 获取智能体卡片的样式
+ */
+export function getAgentCardStyles(): string {
+  return `
+    /* 智能体卡片样式 */
+    .segment-agent {
+      margin: 8px 0;
+    }
+    .agent-card {
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 8px;
+      overflow: hidden;
+      background: var(--vscode-editor-background);
+    }
+    .agent-header {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 8px 12px;
+      background: var(--vscode-sideBar-background);
+      border-bottom: 1px solid var(--vscode-input-border);
+    }
+    .agent-icon {
+      font-size: 16px;
+    }
+    .agent-name {
+      font-weight: 500;
+      flex: 1;
+    }
+    .agent-status {
+      font-size: 11px;
+      padding: 2px 8px;
+      border-radius: 10px;
+    }
+    .agent-status.running {
+      background: var(--vscode-inputValidation-infoBackground);
+      color: var(--vscode-inputValidation-infoForeground);
+    }
+    .agent-status.completed {
+      background: #28a745;
+      color: white;
+    }
+    .agent-status.error {
+      background: #dc3545;
+      color: white;
+    }
+    .agent-body {
+      padding: 8px;
+    }
+    .agent-steps-container {
+      max-height: 150px;
+      overflow-y: auto;
+      font-size: 12px;
+    }
+    .agent-step {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 4px 8px;
+      border-radius: 4px;
+      margin-bottom: 4px;
+      background: var(--vscode-list-hoverBackground);
+    }
+    .agent-step:last-child {
+      margin-bottom: 0;
+    }
+    .step-icon {
+      flex-shrink: 0;
+    }
+    .step-name {
+      font-weight: 500;
+      color: var(--vscode-foreground);
+    }
+    .step-result {
+      color: var(--vscode-descriptionForeground);
+      font-size: 11px;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+    .agent-step-placeholder {
+      color: var(--vscode-descriptionForeground);
+      font-style: italic;
+      padding: 8px;
+      text-align: center;
+    }
+    /* 低调显示的工具调用样式 */
+    .agent-step.low-profile {
+      opacity: 0.85;
+      font-size: 12px;
+      padding: 4px 8px;
+      background: transparent;
+      margin-bottom: 2px;
+    }
+    .agent-step.low-profile .step-icon {
+      opacity: 0.8;
+      font-size: 12px;
+    }
+    .agent-step.low-profile .step-name {
+      font-weight: 400;
+      color: var(--vscode-descriptionForeground);
+      opacity: 0.9;
+    }
+    .agent-step.low-profile .step-result {
+      opacity: 0.85;
+      font-size: 11px;
+    }
+  `;
+}
+
+/**
+ * 获取智能体卡片的脚本
+ */
+export function getAgentCardScript(): string {
+  return `
+    // 工具名称中文映射
+    function getAgentToolDisplayName(toolName) {
+      const toolNameMap = {
+        'file_read': '文件读取',
+        'file_write': '文件写入',
+        'file_delete': '文件删除',
+        'file_list': '检索文件',
+        'syntax_check': '语法检查',
+        'simulation': '仿真',
+        'waveform_summary': '波形分析',
+        'knowledge_save': '保存知识库',
+        'knowledge_load': '加载知识库',
+        'queryKnowledgeSummary': '查询知识摘要',
+        'queryRules': '查询规则',
+        'setModule': '设置模块',
+        'addSignal': '正在分析信号定义',
+        'addSignalExample': '正在处理信号示例',
+        'validateKnowledgeGraph': '验证知识图谱',
+        'querySignals': '查询信号',
+        'addPlan': '添加计划',
+        'addEdge': '添加边',
+        'showPlan': '显示计划',
+        'spawnExplorer': '代码探索',
+        'spawnDebugger': '波形调试',
+        'queryByBFS': 'BFS查询',
+        'queryStateTransitions': '查询状态转移',
+        'addStateTransition': '添加状态转移'
+      };
+      return toolNameMap[toolName] || toolName;
+    }
+
+    /**
+     * 渲染智能体卡片
+     * @param {Object} segment - 智能体段落数据
+     * @param {HTMLElement} segmentDiv - 段落容器元素
+     */
+    function renderAgentCard(segment, segmentDiv) {
+      segmentDiv.className += ' segment-agent';
+
+      const statusText = segment.agentStatus === 'completed' ? '完成'
+        : segment.agentStatus === 'error' ? '错误' : '执行中';
+      const statusClass = segment.agentStatus || 'running';
+
+      const stepsHtml = (segment.agentSteps || []).map(step => {
+        const icon = step.status === 'completed' ? '✅' : step.status === 'error' ? '❌' : '🔄';
+        const displayName = getAgentToolDisplayName(step.toolName);
+        const result = step.toolResult ? \`: \${step.toolResult.substring(0, 50)}\${step.toolResult.length > 50 ? '...' : ''}\` : '';
+        // 所有工具调用都使用低调样式
+        const stepClass = 'agent-step low-profile';
+        return \`<div class="\${stepClass}"><span class="step-icon">\${icon}</span><span class="step-name">\${displayName}</span><span class="step-result">\${result}</span></div>\`;
+      }).join('');
+
+      segmentDiv.innerHTML = \`
+        <div class="agent-card">
+          <div class="agent-header">
+            <span class="agent-icon">${agentIconSvg}</span>
+            <span class="agent-name">\${segment.agentName || '智能体'}</span>
+            <span class="agent-status \${statusClass}">\${statusText}</span>
+          </div>
+          <div class="agent-body">
+            <div class="agent-steps-container">
+              \${stepsHtml || '<div class="agent-step-placeholder">等待执行...</div>'}
+            </div>
+          </div>
+        </div>
+      \`;
+
+      // 自动滚动到最新步骤
+      setTimeout(() => {
+        const container = segmentDiv.querySelector('.agent-steps-container');
+        if (container) {
+          container.scrollTop = container.scrollHeight;
+        }
+      }, 0);
+    }
+  `;
+}

src/views/agentModeSelector.ts

@@ -0,0 +1,231 @@
+/**
+ * 模式选择器组件
+ * 提供 Plan/Ask/Agent 四种模式的选择功能
+ *
+ * 模式说明：
+ * - Plan: 只读模式，只能查询分析，不能写文件
+ * - Ask: 逐个确认，每个写操作需用户确认
+ * - Agent: 智能体自主，自动执行大部分操作
+ */
+
+import {
+  plannerIconSvg,
+  askIconSvg,
+  agentIconSvg,
+} from "../constants/toolIcons";
+
+/**
+ * 获取模式选择器的 HTML 内容
+ */
+export function getModeSelectorContent(): string {
+  return `
+    <div class="tooltip">
+      <div class="mode-select" id="modeSelect">
+        <div class="mode-trigger" onclick="toggleModeDropdown()">
+          <span class="mode-value" id="modeValue">Agent</span>
+          <svg class="mode-arrow" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+            <path d="M507.8 727.728a30.016 30.016 0 0 1-21.288-8.824L231.104 463.496a30.088 30.088 0 0 1 0-42.568 30.088 30.088 0 0 1 42.568 0l234.128 234.128 234.16-234.128a30.088 30.088 0 0 1 42.568 0 30.088 30.088 0 0 1 0 42.568L529.08 718.904a30 30 0 0 1-21.28 8.824z" fill="#8a8a8a"/>
+          </svg>
+        </div>
+        <div class="mode-dropdown" id="modeDropdown">
+          <div class="mode-option" data-value="plan" onclick="selectMode('plan', 'Plan')">
+            <div class="mode-option-header">
+              <span class="mode-option-icon">${plannerIconSvg}</span>
+              <span class="mode-option-label">Plan</span>
+            </div>
+            <span class="mode-option-desc">仅根据需求生成设计文档，之后由用户决定下一步，可以提高工程质量</span>
+          </div>
+          <div class="mode-option" data-value="ask" onclick="selectMode('ask', 'Ask')">
+            <div class="mode-option-header">
+              <span class="mode-option-icon">${askIconSvg}</span>
+              <span class="mode-option-label">Ask</span>
+            </div>
+            <span class="mode-option-desc">仅给与智能体读权限，用于依据项目回答用户问题，或者与用户进行探讨</span>
+          </div>
+          <div class="mode-option selected" data-value="agent" onclick="selectMode('agent', 'Agent')">
+            <div class="mode-option-header">
+              <span class="mode-option-icon">${agentIconSvg}</span>
+              <span class="mode-option-label">Agent</span>
+            </div>
+            <span class="mode-option-desc">用于快速生成工程、调试修改现有代码</span>
+          </div>
+        </div>
+      </div>
+      <span class="tooltiptext" id="modeTooltip">智能体自主模式</span>
+    </div>
+  `;
+}
+
+/**
+ * 获取模式选择器的样式
+ */
+export function getModeSelectorStyles(): string {
+  return `
+    /* 模式选择器样式 */
+    .mode-select {
+      position: relative;
+      user-select: none;
+    }
+    .mode-trigger {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 4px 8px;
+      background: var(--vscode-input-background);
+      color: var(--vscode-foreground);
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 12px;
+      transition: background 0.2s ease;
+    }
+    .mode-trigger:hover {
+      background: var(--vscode-list-hoverBackground);
+    }
+    .mode-value {
+      white-space: nowrap;
+    }
+    .mode-arrow {
+      width: 12px;
+      height: 12px;
+      flex-shrink: 0;
+      transition: transform 0.2s ease;
+    }
+    .mode-select.active .mode-arrow {
+      transform: rotate(180deg);
+    }
+    .mode-dropdown {
+      position: absolute;
+      bottom: calc(100% + 2px);
+      left: 0;
+      min-width: 200px;
+      max-width: 300px;
+      background: var(--vscode-dropdown-background);
+      border: 1px solid var(--vscode-dropdown-border);
+      border-radius: 4px;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+      z-index: 1100;
+      display: none;
+      overflow: hidden;
+    }
+    .mode-select.active .mode-dropdown {
+      display: block;
+    }
+    /* 模式选择器的选项样式 */
+    .mode-option {
+      display: flex;
+      flex-direction: column;
+      align-items: flex-start;
+      padding: 8px 12px;
+      font-size: 12px;
+      cursor: pointer;
+      transition: background 0.2s ease;
+    }
+    .mode-option:hover {
+      background: rgba(128, 128, 128, 0.3);
+    }
+    .mode-option.selected {
+      background: rgba(64, 158, 255, 0.2);
+    }
+    .mode-option-header {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      margin-bottom: 4px;
+    }
+    .mode-option-icon {
+      display: inline-flex;
+      align-items: center;
+      flex-shrink: 0;
+    }
+    .mode-option-icon svg {
+      width: 16px;
+      height: 16px;
+      display: block;
+    }
+    .mode-option-label {
+      font-weight: 500;
+    }
+    .mode-option-desc {
+      font-size: 10px;
+      color: var(--vscode-descriptionForeground);
+      line-height: 1.4;
+      word-wrap: break-word;
+      white-space: normal;
+    }
+  `;
+}
+
+/**
+ * 获取模式选择器的脚本
+ */
+export function getModeSelectorScript(): string {
+  return `
+    // 模式选择器相关变量
+    let currentMode = 'agent';
+
+    // 切换模式下拉框显示/隐藏
+    function toggleModeDropdown() {
+      const modeSelect = document.getElementById('modeSelect');
+      const modelSelect = document.getElementById('modelSelect');
+      if (modeSelect) {
+        modeSelect.classList.toggle('active');
+        // 关闭模型下拉框
+        if (modelSelect) {
+          modelSelect.classList.remove('active');
+        }
+      }
+    }
+
+    // 选择模式
+    function selectMode(value, label) {
+      currentMode = value;
+      const modeValue = document.getElementById('modeValue');
+      const modeTooltip = document.getElementById('modeTooltip');
+
+      if (modeValue) {
+        modeValue.textContent = label;
+      }
+
+      // 更新 tooltip
+      if (modeTooltip) {
+        const tooltipMap = {
+          'plan': 'plan模式',
+          'ask': 'ask模式',
+          'agent': 'agent模式'
+        };
+        modeTooltip.textContent = tooltipMap[value] || '切换模式';
+      }
+
+      // 更新选中状态
+      const options = document.querySelectorAll('.mode-option');
+      options.forEach(option => {
+        if (option.getAttribute('data-value') === value) {
+          option.classList.add('selected');
+        } else {
+          option.classList.remove('selected');
+        }
+      });
+
+      // 关闭下拉框
+      const modeSelect = document.getElementById('modeSelect');
+      if (modeSelect) {
+        modeSelect.classList.remove('active');
+      }
+    }
+
+    // 获取当前模式
+    function getCurrentMode() {
+      return currentMode;
+    }
+
+    // 点击外部关闭模式下拉框
+    document.addEventListener('click', (event) => {
+      const modeSelect = document.getElementById('modeSelect');
+
+      if (modeSelect && !modeSelect.contains(event.target)) {
+        modeSelect.classList.remove('active');
+      }
+    });
+  `;
+}

src/views/contextButton.ts

@@ -0,0 +1,508 @@
+/**
+ * 添加上下文按钮组件
+ */
+
+/**
+ * 获取添加上下文按钮的 HTML 内容
+ */
+export function getContextButtonContent(): string {
+  return `
+    <div class="context-selector-wrapper">
+      <div class="tooltip">
+        <button class="add-context-button" onclick="toggleContextMenu()">
+          <svg t="1766915545722" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="4994" width="200" height="200">
+            <path d="M469.333333 469.333333V170.666667h85.333334v298.666666h298.666666v85.333334h-298.666666v298.666666h-85.333334v-298.666666H170.666667v-85.333334h298.666666z" fill="#8a8a8a" p-id="4995"></path>
+          </svg>
+          <span class="add-context-label">添加上下文</span>
+          <svg class="dropdown-arrow" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+            <path d="M512 714.666667L213.333333 416l42.666667-42.666667L512 629.333333l256-256 42.666667 42.666667z" fill="currentColor"/>
+          </svg>
+        </button>
+        <span class="tooltiptext">添加文件、文件夹、图片或文档作为上下文</span>
+      </div>
+
+      <!-- 上拉菜单 -->
+      <div class="context-menu" id="contextMenu">
+        <!-- 主菜单 -->
+        <div class="context-menu-main" id="contextMenuMain">
+          <div class="context-menu-item" onclick="showFileList()">
+            <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+              <path d="M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7zM790.2 326H602V137.8L790.2 326z m1.8 562H232V136h302v216c0 23.2 18.8 42 42 42h216v494z" fill="currentColor"/>
+            </svg>
+            <span>文件</span>
+            <svg class="arrow-right" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+              <path d="M340.864 149.312l384 384-384 384-45.248-45.248L634.368 533.312 295.616 194.56z" fill="currentColor"/>
+            </svg>
+          </div>
+          <div class="context-menu-item" onclick="showFolderList()">
+            <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+              <path d="M880 298.4H521L403.7 186.2c-1.5-1.4-3.5-2.2-5.5-2.2H144c-17.7 0-32 14.3-32 32v592c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V330.4c0-17.7-14.3-32-32-32zM840 768H184V256h188.5l119.6 114.4H840V768z" fill="currentColor"/>
+            </svg>
+            <span>文件夹</span>
+            <svg class="arrow-right" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+              <path d="M340.864 149.312l384 384-384 384-45.248-45.248L634.368 533.312 295.616 194.56z" fill="currentColor"/>
+            </svg>
+          </div>
+          <div class="context-menu-item" onclick="handleAddImage()">
+            <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+              <path d="M928 160H96c-17.7 0-32 14.3-32 32v640c0 17.7 14.3 32 32 32h832c17.7 0 32-14.3 32-32V192c0-17.7-14.3-32-32-32z m-40 632H136V232h752v560z m-120-240c0 55.2-44.8 100-100 100s-100-44.8-100-100 44.8-100 100-100 100 44.8 100 100z m-476 0l164 164h476L696 480 536 640l-84-84-160 160z" fill="currentColor"/>
+            </svg>
+            <span>图片</span>
+          </div>
+          <div class="context-menu-item" onclick="handleAddDocument()">
+            <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+              <path d="M832 64H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V96c0-17.7-14.3-32-32-32z m-40 824H232V136h560v752z m-120-568H352c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8h320c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8z m0 144H352c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8h320c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8z m0 144H352c-4.4 0-8 3.6-8 8v48c0 4.4 3.6 8 8 8h320c4.4 0 8-3.6 8-8v-48c0-4.4-3.6-8-8-8z" fill="currentColor"/>
+            </svg>
+            <span>文档库</span>
+          </div>
+        </div>
+
+        <!-- 文件/文件夹列表视图 -->
+        <div class="context-menu-list" id="contextMenuList" style="display: none;">
+          <div class="context-menu-list-header">
+            <button class="context-menu-back" onclick="backToMainMenu()">
+              <svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+                <path d="M724 218.3V141c0-6.7-7.7-10.4-12.9-6.3L260.3 486.8c-16.4 12.8-16.4 37.5 0 50.3l450.8 352.1c5.3 4.1 12.9 0.4 12.9-6.3v-77.3c0-4.9-2.3-9.6-6.1-12.6l-360-281 360-281.1c3.8-3 6.1-7.7 6.1-12.6z" fill="currentColor"/>
+              </svg>
+            </button>
+            <span id="contextMenuListTitle">选择文件</span>
+          </div>
+          <div class="context-menu-list-body" id="contextMenuListBody">
+            <!-- 动态加载列表 -->
+          </div>
+          <div class="context-menu-list-footer">
+            <input type="text" id="contextMenuSearch" placeholder="搜索..." />
+            <div class="context-menu-list-actions">
+              <span id="contextMenuListCount">已选择 0 项</span>
+              <button class="primary" onclick="confirmSelection()">确定</button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+/**
+ * 获取添加上下文按钮的样式
+ */
+export function getContextButtonStyles(): string {
+  return `
+    /* 上下文选择器容器 */
+    .context-selector-wrapper {
+      position: relative;
+      display: inline-block;
+    }
+
+    /* 添加上下文按钮样式 */
+    .add-context-button {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 6px 12px;
+      background: rgba(128, 128, 128, 0.2);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 6px;
+      color: var(--vscode-foreground);
+      cursor: pointer;
+      transition: all 0.2s ease;
+      font-size: 13px;
+      font-weight: 500;
+    }
+
+    .add-context-button:hover {
+      background: rgba(128, 128, 128, 0.3);
+      border-color: var(--vscode-focusBorder);
+    }
+
+    .add-context-button svg.icon {
+      width: 16px;
+      height: 16px;
+      color: #409eff;
+    }
+
+    .add-context-button .dropdown-arrow {
+      width: 12px;
+      height: 12px;
+      transition: transform 0.2s ease;
+    }
+
+    .add-context-button.active .dropdown-arrow {
+      transform: rotate(180deg);
+    }
+
+    .add-context-label {
+      white-space: nowrap;
+    }
+
+    /* 上拉菜单样式 */
+    .context-menu {
+      position: absolute;
+      bottom: calc(100% + 8px);
+      left: 0;
+      background: var(--vscode-dropdown-background);
+      border: 1px solid var(--vscode-dropdown-border);
+      border-radius: 6px;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.3);
+      min-width: 180px;
+      z-index: 1000;
+      display: none;
+      overflow: hidden;
+    }
+
+    .context-menu.show {
+      display: block;
+      animation: slideUp 0.2s ease;
+    }
+
+    @keyframes slideUp {
+      from {
+        opacity: 0;
+        transform: translateY(10px);
+      }
+      to {
+        opacity: 1;
+        transform: translateY(0);
+      }
+    }
+
+    .context-menu-item {
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      padding: 10px 16px;
+      cursor: pointer;
+      transition: background 0.2s ease;
+      color: var(--vscode-foreground);
+    }
+
+    .context-menu-item:hover {
+      background: var(--vscode-list-hoverBackground);
+    }
+
+    .context-menu-item svg {
+      width: 18px;
+      height: 18px;
+      flex-shrink: 0;
+      color: var(--vscode-foreground);
+      opacity: 0.8;
+    }
+
+    .context-menu-item span {
+      font-size: 13px;
+      white-space: nowrap;
+      flex: 1;
+    }
+
+    .context-menu-item .arrow-right {
+      width: 14px;
+      height: 14px;
+      opacity: 0.6;
+      margin-left: auto;
+    }
+
+    /* 列表视图样式 */
+    .context-menu-list {
+      display: flex;
+      flex-direction: column;
+      max-height: 350px;
+    }
+
+    .context-menu-list-header {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 10px 12px;
+      border-bottom: 1px solid var(--vscode-panel-border);
+    }
+
+    .context-menu-back {
+      width: 28px;
+      height: 28px;
+      padding: 0;
+      border: none;
+      background: transparent;
+      color: var(--vscode-foreground);
+      cursor: pointer;
+      border-radius: 4px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+
+    .context-menu-back:hover {
+      background: var(--vscode-toolbar-hoverBackground);
+    }
+
+    .context-menu-back svg {
+      width: 16px;
+      height: 16px;
+    }
+
+    .context-menu-list-header span {
+      font-size: 14px;
+      font-weight: 500;
+      flex: 1;
+    }
+
+    .context-menu-list-body {
+      flex: 1;
+      overflow-y: auto;
+      padding: 4px;
+    }
+
+    .context-menu-list-item {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 6px 8px;
+      cursor: pointer;
+      border-radius: 4px;
+      transition: background 0.2s ease;
+    }
+
+    .context-menu-list-item:hover {
+      background: var(--vscode-list-hoverBackground);
+    }
+
+    .context-menu-list-item.selected {
+      background: var(--vscode-list-activeSelectionBackground);
+    }
+
+    .context-menu-list-item input[type="checkbox"] {
+      width: 14px;
+      height: 14px;
+      flex-shrink: 0;
+    }
+
+    .context-menu-list-item label {
+      flex: 1;
+      font-size: 12px;
+      cursor: pointer;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .context-menu-list-footer {
+      padding: 8px 12px;
+      border-top: 1px solid var(--vscode-panel-border);
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+    }
+
+    .context-menu-list-footer input {
+      width: 100%;
+      padding: 6px 10px;
+      background: var(--vscode-input-background);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 4px;
+      color: var(--vscode-input-foreground);
+      font-size: 12px;
+      box-sizing: border-box;
+    }
+
+    .context-menu-list-actions {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+    }
+
+    .context-menu-list-footer span {
+      font-size: 12px;
+      color: var(--vscode-descriptionForeground);
+    }
+
+    .context-menu-list-footer button {
+      padding: 4px 12px;
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 12px;
+    }
+
+    .context-menu-list-footer button:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+  `;
+}
+
+/**
+ * 获取添加上下文按钮的脚本
+ */
+export function getContextButtonScript(): string {
+  return `
+    // 上下文菜单状态
+    let currentListData = [];
+    let currentListType = '';
+    let selectedItems = new Set();
+
+    // 切换上下文菜单显示/隐藏
+    function toggleContextMenu() {
+      const menu = document.getElementById('contextMenu');
+      const button = document.querySelector('.add-context-button');
+
+      if (menu && button) {
+        const isShown = menu.classList.contains('show');
+
+        if (isShown) {
+          menu.classList.remove('show');
+          button.classList.remove('active');
+          backToMainMenu(); // 关闭时回到主菜单
+        } else {
+          menu.classList.add('show');
+          button.classList.add('active');
+        }
+      }
+    }
+
+    // 点击外部关闭菜单
+    document.addEventListener('click', function(event) {
+      const wrapper = document.querySelector('.context-selector-wrapper');
+      const menu = document.getElementById('contextMenu');
+      const button = document.querySelector('.add-context-button');
+
+      if (wrapper && menu && button && !wrapper.contains(event.target)) {
+        menu.classList.remove('show');
+        button.classList.remove('active');
+        backToMainMenu();
+      }
+    });
+
+    // 显示文件列表
+    function showFileList() {
+      vscode.postMessage({ command: 'addContextFile' });
+    }
+
+    // 显示文件夹列表
+    function showFolderList() {
+      vscode.postMessage({ command: 'addContextFolder' });
+    }
+
+    // 返回主菜单
+    function backToMainMenu() {
+      const mainMenu = document.getElementById('contextMenuMain');
+      const listView = document.getElementById('contextMenuList');
+
+      if (mainMenu && listView) {
+        mainMenu.style.display = 'block';
+        listView.style.display = 'none';
+      }
+
+      selectedItems.clear();
+      currentListData = [];
+    }
+
+    // 切换到列表视图
+    function switchToListView(title, type, data) {
+      const mainMenu = document.getElementById('contextMenuMain');
+      const listView = document.getElementById('contextMenuList');
+      const titleEl = document.getElementById('contextMenuListTitle');
+
+      if (mainMenu && listView && titleEl) {
+        mainMenu.style.display = 'none';
+        listView.style.display = 'flex';
+        titleEl.textContent = title;
+
+        currentListType = type;
+        currentListData = data;
+        selectedItems.clear();
+
+        renderList(data);
+        updateSelectedCount();
+      }
+    }
+
+    // 渲染列表
+    function renderList(data) {
+      const body = document.getElementById('contextMenuListBody');
+      if (!body) return;
+
+      body.innerHTML = data.map((item, index) => \`
+        <div class="context-menu-list-item" onclick="toggleItemSelection(\${index})">
+          <input type="checkbox" id="item-\${index}" />
+          <label for="item-\${index}">\${item.relativePath}</label>
+        </div>
+      \`).join('');
+    }
+
+    // 切换项选择
+    function toggleItemSelection(index) {
+      const checkbox = document.getElementById('item-' + index);
+      const item = document.querySelectorAll('.context-menu-list-item')[index];
+
+      if (checkbox && item) {
+        checkbox.checked = !checkbox.checked;
+
+        if (checkbox.checked) {
+          selectedItems.add(index);
+          item.classList.add('selected');
+        } else {
+          selectedItems.delete(index);
+          item.classList.remove('selected');
+        }
+
+        updateSelectedCount();
+      }
+    }
+
+    // 更新选中数量
+    function updateSelectedCount() {
+      const countEl = document.getElementById('contextMenuListCount');
+      if (countEl) {
+        countEl.textContent = '已选择 ' + selectedItems.size + ' 项';
+      }
+    }
+
+    // 确认选择
+    function confirmSelection() {
+      const selected = Array.from(selectedItems).map(index => currentListData[index]);
+
+      if (selected.length > 0) {
+        selected.forEach(item => {
+          addContextItem(currentListType, item.path);
+        });
+      }
+
+      toggleContextMenu();
+    }
+
+    // 添加图片
+    function handleAddImage() {
+      vscode.postMessage({ command: 'addContextImage' });
+      toggleContextMenu();
+    }
+
+    // 添加文档
+    function handleAddDocument() {
+      vscode.postMessage({ command: 'addContextDocument' });
+      toggleContextMenu();
+    }
+
+    // 搜索功能
+    const searchInput = document.getElementById('contextMenuSearch');
+    if (searchInput) {
+      searchInput.addEventListener('input', function(e) {
+        const keyword = e.target.value.toLowerCase();
+        const filtered = currentListData.filter(item =>
+          item.relativePath.toLowerCase().includes(keyword)
+        );
+        renderList(filtered);
+      });
+    }
+
+    // 处理后端消息
+    window.addEventListener('message', event => {
+      const message = event.data;
+
+      if (message.command === 'showWorkspaceFileList') {
+        switchToListView('选择文件', 'file', message.files);
+      } else if (message.command === 'showWorkspaceFolderList') {
+        switchToListView('选择文件夹', 'folder', message.folders);
+      }
+    });
+  `;
+}

src/views/contextCompress.ts

@@ -0,0 +1,249 @@
+/**
+ * 上下文压缩组件
+ * 提供上下文使用情况显示和压缩功能
+ */
+
+/**
+ * 获取上下文压缩组件的 HTML 内容
+ */
+export function getContextCompressContent(): string {
+  return `
+    <!-- 上下文显示 -->
+    <div class="context-display">
+      <div class="context-info" onclick="toggleContextPanel()">
+        <div class="database-icon">
+          <svg viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" class="db-svg">
+            <!-- 数据库容器主体 - 底层灰色 -->
+            <path d="M870.4 57.6C780.8 19.2 652.8 0 512 0 371.2 0 243.2 19.2 153.6 57.6 51.2 102.4 0 153.6 0 211.2l0 595.2c0 57.6 51.2 115.2 153.6 153.6C243.2 1004.8 371.2 1024 512 1024c140.8 0 268.8-19.2 358.4-57.6 96-38.4 153.6-96 153.6-153.6L1024 211.2C1024 153.6 972.8 102.4 870.4 57.6L870.4 57.6zM812.8 320C729.6 352 614.4 364.8 512 364.8 403.2 364.8 294.4 352 211.2 320 115.2 294.4 70.4 256 70.4 211.2c0-38.4 51.2-76.8 140.8-108.8C294.4 76.8 403.2 64 512 64c102.4 0 217.6 19.2 300.8 44.8 89.6 32 140.8 70.4 140.8 108.8C953.6 256 908.8 294.4 812.8 320L812.8 320zM819.2 505.6C736 531.2 620.8 550.4 512 550.4c-108.8 0-217.6-19.2-307.2-44.8C115.2 473.6 64 435.2 64 396.8L64 326.4C128 352 172.8 384 243.2 396.8 326.4 416 416 428.8 512 428.8c96 0 185.6-12.8 268.8-32C851.2 384 896 352 960 326.4l0 76.8C960 435.2 908.8 473.6 819.2 505.6L819.2 505.6zM819.2 710.4c-83.2 25.6-198.4 44.8-307.2 44.8-108.8 0-217.6-19.2-307.2-44.8C115.2 684.8 64 646.4 64 601.6L64 505.6c64 32 108.8 57.6 179.2 76.8C326.4 601.6 416 614.4 512 614.4c96 0 185.6-12.8 268.8-32C851.2 563.2 896 537.6 960 505.6l0 96C960 646.4 908.8 684.8 819.2 710.4L819.2 710.4zM512 960c-108.8 0-217.6-19.2-307.2-44.8C115.2 889.6 64 851.2 64 812.8l0-96c64 32 108.8 57.6 179.2 76.8 76.8 19.2 172.8 32 262.4 32 96 0 185.6-12.8 268.8-32 76.8-19.2 121.6-44.8 185.6-76.8l0 96c0 38.4-51.2 76.8-140.8 108.8C736 947.2 614.4 960 512 960L512 960z" fill="#94a3b8" class="db-body"/>
+
+            <!-- 填充进度效果 - 从下往上填充蓝色 -->
+            <defs>
+              <mask id="fill-mask">
+                <rect x="0" y="0" width="1024" height="1024" id="fillRect" fill="white"/>
+              </mask>
+            </defs>
+
+            <g mask="url(#fill-mask)">
+              <path d="M870.4 57.6C780.8 19.2 652.8 0 512 0 371.2 0 243.2 19.2 153.6 57.6 51.2 102.4 0 153.6 0 211.2l0 595.2c0 57.6 51.2 115.2 153.6 153.6C243.2 1004.8 371.2 1024 512 1024c140.8 0 268.8-19.2 358.4-57.6 96-38.4 153.6-96 153.6-153.6L1024 211.2C1024 153.6 972.8 102.4 870.4 57.6L870.4 57.6zM812.8 320C729.6 352 614.4 364.8 512 364.8 403.2 364.8 294.4 352 211.2 320 115.2 294.4 70.4 256 70.4 211.2c0-38.4 51.2-76.8 140.8-108.8C294.4 76.8 403.2 64 512 64c102.4 0 217.6 19.2 300.8 44.8 89.6 32 140.8 70.4 140.8 108.8C953.6 256 908.8 294.4 812.8 320L812.8 320zM819.2 505.6C736 531.2 620.8 550.4 512 550.4c-108.8 0-217.6-19.2-307.2-44.8C115.2 473.6 64 435.2 64 396.8L64 326.4C128 352 172.8 384 243.2 396.8 326.4 416 416 428.8 512 428.8c96 0 185.6-12.8 268.8-32C851.2 384 896 352 960 326.4l0 76.8C960 435.2 908.8 473.6 819.2 505.6L819.2 505.6zM819.2 710.4c-83.2 25.6-198.4 44.8-307.2 44.8-108.8 0-217.6-19.2-307.2-44.8C115.2 684.8 64 646.4 64 601.6L64 505.6c64 32 108.8 57.6 179.2 76.8C326.4 601.6 416 614.4 512 614.4c96 0 185.6-12.8 268.8-32C851.2 563.2 896 537.6 960 505.6l0 96C960 646.4 908.8 684.8 819.2 710.4L819.2 710.4zM512 960c-108.8 0-217.6-19.2-307.2-44.8C115.2 889.6 64 851.2 64 812.8l0-96c64 32 108.8 57.6 179.2 76.8 76.8 19.2 172.8 32 262.4 32 96 0 185.6-12.8 268.8-32 76.8-19.2 121.6-44.8 185.6-76.8l0 96c0 38.4-51.2 76.8-140.8 108.8C736 947.2 614.4 960 512 960L512 960z" fill="#409eff" class="db-fill"/>
+            </g>
+          </svg>
+        </div>
+        <span class="context-percentage" id="contextPercentage">0%</span>
+      </div>
+
+      <!-- 上下文信息弹窗 -->
+      <div id="contextPanel" class="context-panel">
+        <div class="context-panel-content">
+          <div class="context-info-text" id="contextInfoText">
+            0k / 200k 已用上下文
+          </div>
+          <button class="compress-button" onclick="compressConversation()">
+            压缩会话
+          </button>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+/**
+ * 获取上下文压缩组件的样式
+ */
+export function getContextCompressStyles(): string {
+  return `
+    /* 上下文显示样式 */
+    .context-display {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      position: relative;
+    }
+    .context-info {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      height: 40px;
+      background: transparent;
+      border: none;
+      border-radius: 4px;
+      font-size: 14px;
+      font-weight: 500;
+      color: var(--vscode-foreground);
+      transition: opacity 0.3s ease;
+      box-shadow: none;
+      position: relative;
+      overflow: hidden;
+      cursor: pointer;
+    }
+    .context-info:hover {
+      opacity: 0.8;
+    }
+    .database-icon {
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      width: 12px;
+      height: 12px;
+      position: relative;
+    }
+    .db-svg {
+      width: 100%;
+      height: 100%;
+    }
+    .db-body {
+      fill: #ffffff;
+    }
+    .db-fill {
+      fill: #409eff;
+      transition: all 0.3s ease;
+    }
+    .context-percentage {
+      font-size: 14px;
+      font-weight: 500;
+      color: var(--vscode-foreground);
+      text-align: right;
+    }
+    /* 上下文信息弹窗样式 */
+    .context-panel {
+      position: absolute;
+      bottom: 100%;
+      left: 50%;
+      transform: translateX(-50%);
+      margin-bottom: 8px;
+      z-index: 1000;
+      animation: fadeInUp 0.2s ease-out;
+      display: none;
+    }
+    .context-panel.active {
+      display: block;
+    }
+    .context-panel::after {
+      content: "";
+      position: absolute;
+      bottom: -6px;
+      left: 50%;
+      transform: translateX(-50%);
+      width: 0;
+      height: 0;
+      border-left: 6px solid transparent;
+      border-right: 6px solid transparent;
+      border-top: 6px solid #ffffff;
+    }
+    .context-panel-content {
+      background: #ffffff;
+      border: 1px solid rgba(0, 0, 0, 0.1);
+      border-radius: 8px;
+      padding: 12px;
+      box-shadow: 0 4px 20px rgba(0, 0, 0, 0.15);
+      backdrop-filter: blur(10px);
+      min-width: 160px;
+    }
+    .context-info-text {
+      font-size: 12px;
+      color: #374151;
+      text-align: center;
+      margin-bottom: 8px;
+      white-space: nowrap;
+    }
+    .compress-button {
+      width: 100%;
+      background: linear-gradient(145deg, #3b82f6 0%, #1d4ed8 100%);
+      border: 1px solid rgba(59, 130, 246, 0.3);
+      border-radius: 6px;
+      color: white;
+      font-size: 12px;
+      font-weight: 500;
+      padding: 6px 12px;
+      cursor: pointer;
+      transition: all 0.2s ease;
+    }
+    .compress-button:hover {
+      background: linear-gradient(145deg, #2563eb 0%, #1e40af 100%);
+      transform: translateY(-1px);
+      box-shadow: 0 2px 8px rgba(59, 130, 246, 0.3);
+    }
+    .compress-button:active {
+      transform: translateY(0);
+    }
+    @keyframes fadeInUp {
+      from {
+        opacity: 0;
+        transform: translateX(-50%) translateY(10px);
+      }
+      to {
+        opacity: 1;
+        transform: translateX(-50%) translateY(0);
+      }
+    }
+  `;
+}
+
+/**
+ * 获取上下文压缩组件的脚本
+ */
+export function getContextCompressScript(): string {
+  return `
+    // 上下文面板相关函数
+    function toggleContextPanel() {
+      const contextPanel = document.getElementById('contextPanel');
+      if (contextPanel) {
+        if (contextPanel.classList.contains('active')) {
+          contextPanel.classList.remove('active');
+        } else {
+          contextPanel.classList.add('active');
+        }
+      }
+    }
+
+    function compressConversation() {
+      // 发送压缩会话请求
+      vscode.postMessage({ command: 'compressConversation' });
+      addMessage('正在压缩会话...', 'bot');
+
+      // 关闭面板
+      const contextPanel = document.getElementById('contextPanel');
+      if (contextPanel) {
+        contextPanel.classList.remove('active');
+      }
+    }
+
+    function updateContextDisplay(currentTokens, maxTokens) {
+      const percentage = Math.min(Math.round((currentTokens / maxTokens) * 100), 100);
+
+      // 更新百分比显示
+      const contextPercentage = document.getElementById('contextPercentage');
+      if (contextPercentage) {
+        contextPercentage.textContent = percentage + '%';
+      }
+
+      // 更新详细信息
+      const contextInfoText = document.getElementById('contextInfoText');
+      if (contextInfoText) {
+        const currentK = Math.round((currentTokens / 1000) * 10) / 10;
+        const maxK = Math.round(maxTokens / 1000);
+        contextInfoText.textContent = \`\${currentK}k / \${maxK}k 已用上下文\`;
+      }
+
+      // 更新SVG填充效果（从下往上填充）
+      const fillRect = document.getElementById('fillRect');
+      if (fillRect) {
+        const fillHeight = (1024 * percentage) / 100;
+        const fillY = 1024 - fillHeight;
+        fillRect.setAttribute('y', fillY.toString());
+        fillRect.setAttribute('height', fillHeight.toString());
+      }
+    }
+
+    // 点击外部关闭上下文面板
+    document.addEventListener('click', (event) => {
+      const contextDisplay = document.querySelector('.context-display');
+      const contextPanel = document.getElementById('contextPanel');
+
+      if (contextPanel && contextPanel.classList.contains('active') && contextDisplay) {
+        if (!contextDisplay.contains(event.target)) {
+          contextPanel.classList.remove('active');
+        }
+      }
+    });
+  `;
+}

src/views/contextDisplay.ts

@@ -0,0 +1,225 @@
+/**
+ * 上下文显示组件
+ * 用于显示已选择的文件、文件夹、图片和文档
+ */
+
+/**
+ * 获取上下文显示区域的 HTML 内容
+ */
+export function getContextDisplayContent(): string {
+  return `
+    <div class="context-display-area" id="contextDisplayArea" style="display: none;">
+      <div class="context-items-container" id="contextItemsContainer">
+        <!-- 动态添加的上下文项将显示在这里 -->
+      </div>
+    </div>
+  `;
+}
+
+/**
+ * 获取上下文显示区域的样式
+ */
+export function getContextDisplayStyles(): string {
+  return `
+    /* 上下文显示区域 */
+    .context-display-area {
+      margin-bottom: 8px;
+      padding: 8px;
+      background: rgba(128, 128, 128, 0.1);
+      border-radius: 6px;
+      border: 1px solid var(--vscode-input-border);
+    }
+
+    .context-items-container {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+
+    /* 上下文项样式 */
+    .context-item {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 6px 10px;
+      background: var(--vscode-input-background);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 4px;
+      font-size: 12px;
+      color: var(--vscode-foreground);
+      max-width: 300px;
+      transition: all 0.2s ease;
+    }
+
+    .context-item:hover {
+      background: var(--vscode-list-hoverBackground);
+    }
+
+    .context-item svg {
+      width: 14px;
+      height: 14px;
+      flex-shrink: 0;
+      opacity: 0.8;
+    }
+
+    .context-item-name {
+      flex: 1;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
+
+    .context-item-remove {
+      width: 14px;
+      height: 14px;
+      cursor: pointer;
+      opacity: 0.6;
+      transition: opacity 0.2s ease;
+      flex-shrink: 0;
+    }
+
+    .context-item-remove:hover {
+      opacity: 1;
+      color: #f56c6c;
+    }
+
+    /* 图片预览样式 */
+    .context-item.image-item {
+      position: relative;
+    }
+
+    .context-item-preview {
+      width: 40px;
+      height: 40px;
+      object-fit: cover;
+      border-radius: 3px;
+      border: 1px solid var(--vscode-input-border);
+    }
+  `;
+}
+
+/**
+ * 获取上下文显示区域的脚本
+ */
+export function getContextDisplayScript(): string {
+  return `
+    // 存储上下文项
+    let contextItems = [];
+
+    // 获取文件图标 SVG
+    function getFileIcon() {
+      return '<svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg"><path d="M854.6 288.6L639.4 73.4c-6-6-14.1-9.4-22.6-9.4H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V311.3c0-8.5-3.4-16.7-9.4-22.7z" fill="currentColor"/></svg>';
+    }
+
+    // 获取文件夹图标 SVG
+    function getFolderIcon() {
+      return '<svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg"><path d="M880 298.4H521L403.7 186.2c-1.5-1.4-3.5-2.2-5.5-2.2H144c-17.7 0-32 14.3-32 32v592c0 17.7 14.3 32 32 32h736c17.7 0 32-14.3 32-32V330.4c0-17.7-14.3-32-32-32z" fill="currentColor"/></svg>';
+    }
+
+    // 获取图片图标 SVG
+    function getImageIcon() {
+      return '<svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg"><path d="M928 160H96c-17.7 0-32 14.3-32 32v640c0 17.7 14.3 32 32 32h832c17.7 0 32-14.3 32-32V192c0-17.7-14.3-32-32-32z" fill="currentColor"/></svg>';
+    }
+
+    // 获取文档图标 SVG
+    function getDocumentIcon() {
+      return '<svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg"><path d="M832 64H192c-17.7 0-32 14.3-32 32v832c0 17.7 14.3 32 32 32h640c17.7 0 32-14.3 32-32V96c0-17.7-14.3-32-32-32z" fill="currentColor"/></svg>';
+    }
+
+    // 获取删除图标 SVG
+    function getRemoveIcon() {
+      return '<svg viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg"><path d="M563.8 512l262.5-312.9c4.4-5.2.7-13.1-6.1-13.1h-79.8c-4.7 0-9.2 2.1-12.3 5.7L511.6 449.8 295.1 191.7c-3-3.6-7.5-5.7-12.3-5.7H203c-6.8 0-10.5 7.9-6.1 13.1L459.4 512 196.9 824.9c-4.4 5.2-.7 13.1 6.1 13.1h79.8c4.7 0 9.2-2.1 12.3-5.7l216.5-258.1 216.5 258.1c3 3.6 7.5 5.7 12.3 5.7h79.8c6.8 0 10.5-7.9 6.1-13.1L563.8 512z" fill="currentColor"/></svg>';
+    }
+
+    // 提取文件名
+    function getFileName(path) {
+      return path.split(/[\\\\/]/).pop();
+    }
+
+    // 添加上下文项
+    function addContextItem(type, path) {
+      const id = Date.now() + Math.random();
+      contextItems.push({ id, type, path });
+      renderContextItems();
+    }
+
+    // 删除上下文项
+    function removeContextItem(id) {
+      contextItems = contextItems.filter(item => item.id !== id);
+      renderContextItems();
+    }
+
+    // 渲染上下文项
+    function renderContextItems() {
+      const container = document.getElementById('contextItemsContainer');
+      const displayArea = document.getElementById('contextDisplayArea');
+
+      if (!container || !displayArea) return;
+
+      if (contextItems.length === 0) {
+        displayArea.style.display = 'none';
+        return;
+      }
+
+      displayArea.style.display = 'block';
+      container.innerHTML = contextItems.map(item => {
+        let icon = '';
+        switch(item.type) {
+          case 'file': icon = getFileIcon(); break;
+          case 'folder': icon = getFolderIcon(); break;
+          case 'image': icon = getImageIcon(); break;
+          case 'document': icon = getDocumentIcon(); break;
+        }
+
+        return \`
+          <div class="context-item" title="\${item.path}">
+            \${icon}
+            <span class="context-item-name">\${getFileName(item.path)}</span>
+            <span class="context-item-remove" onclick="removeContextItem(\${item.id})">
+              \${getRemoveIcon()}
+            </span>
+          </div>
+        \`;
+      }).join('');
+    }
+
+    // 处理后端返回的文件选择结果
+    window.addEventListener('message', event => {
+      const message = event.data;
+
+      switch(message.command) {
+        case 'contextFilesSelected':
+          if (message.files && message.files.length > 0) {
+            message.files.forEach(file => addContextItem('file', file));
+          }
+          break;
+        case 'contextFoldersSelected':
+          if (message.folders && message.folders.length > 0) {
+            message.folders.forEach(folder => addContextItem('folder', folder));
+          }
+          break;
+        case 'contextImagesSelected':
+          if (message.images && message.images.length > 0) {
+            message.images.forEach(image => addContextItem('image', image));
+          }
+          break;
+        case 'contextDocumentsSelected':
+          if (message.documents && message.documents.length > 0) {
+            message.documents.forEach(doc => addContextItem('document', doc));
+          }
+          break;
+      }
+    });
+
+    // 获取所有上下文项（供发送消息时使用）
+    window.getContextItems = function() {
+      return contextItems;
+    };
+
+    // 清空上下文项（供清空对话时使用）
+    window.clearContextItems = function() {
+      contextItems = [];
+      renderContextItems();
+    };
+  `;
+}

src/views/conversationHistoryBar.ts

@@ -1,3 +1,10 @@
+import {
+  getUserInfoComponentContent,
+  getUserInfoComponentStyles,
+  getUserInfoComponentScript,
+} from "./userInfoComponent";
+import { userAvatarIconSvg } from "../constants/toolIcons";
+
 /**
  * 获取会话历史栏的 HTML 内容
  */
@@ -6,7 +13,7 @@ export function getConversationHistoryBarContent(): string {
     <div class="conversation-history-bar">
       <div class="history-dropdown-container">
         <button class="history-dropdown-button" onclick="toggleHistoryDropdown()">
-          <span class="dropdown-label">Past Conversations</span>
+          <span class="dropdown-label">历史对话</span>
           <svg class="dropdown-icon" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
             <path d="M884 256h-75c-5.1 0-9.9 2.5-12.9 6.6L512 654.2 227.9 262.6c-3-4.1-7.8-6.6-12.9-6.6h-75c-6.5 0-10.3 7.4-6.5 12.7l352.6 486.1c12.8 17.6 39 17.6 51.7 0l352.6-486.1c3.9-5.3 0.1-12.7-6.4-12.7z" fill="currentColor"/>
           </svg>
@@ -19,11 +26,20 @@ export function getConversationHistoryBarContent(): string {
         </div>
       </div>
 
-      <button class="new-conversation-button" onclick="createNewConversation()" title="新建对话">
+      <div class="right-actions">
-        <svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+        <button class="new-conversation-button" onclick="createNewConversation()" title="新建对话">
-          <path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z" fill="currentColor"/>
+          <svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
-        </svg>
+            <path d="M19 13h-6v6h-2v-6H5v-2h6V5h2v6h6v2z" fill="currentColor"/>
-      </button>
+          </svg>
+        </button>
+
+        <div class="user-info-container">
+          <button class="user-avatar-icon-button" id="userAvatarIconButton" style="display: none;" title="查看用户信息" onclick="openUserDetailModal()">
+            ${userAvatarIconSvg}
+          </button>
+          ${getUserInfoComponentContent()}
+        </div>
+      </div>
     </div>
   `;
 }
@@ -49,13 +65,59 @@ export function getConversationHistoryBarStyles(): string {
       flex: 1;
     }
 
+    .right-actions {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .user-info-container {
+      position: relative;
+    }
+
+    .user-avatar-icon-button {
+      width: 36px;
+      height: 36px;
+      padding: 0;
+      background: transparent;
+      color: var(--vscode-foreground);
+      border: none;
+      border-radius: 50%;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: all 0.2s ease;
+      flex-shrink: 0;
+    }
+
+    .user-avatar-icon-button:hover {
+      background: var(--vscode-toolbar-hoverBackground);
+      transform: scale(1.1);
+    }
+
+    .user-avatar-icon-button:active {
+      transform: scale(0.95);
+    }
+
+    .user-avatar-icon-button.active {
+      background: var(--vscode-toolbar-hoverBackground);
+    }
+
+    .user-avatar-icon-button svg {
+      width: 20px;
+      height: 20px;
+    }
+
+    ${getUserInfoComponentStyles()}
+
     .history-dropdown-button {
       display: inline-flex;
       align-items: center;
       gap: 6px;
       padding: 8px 12px;
       background: transparent;
-      color: var(--vscode-input-foreground);
+      color: var(--vscode-foreground);
       border: none;
       border-radius: 4px;
       cursor: pointer;
@@ -64,7 +126,7 @@ export function getConversationHistoryBarStyles(): string {
     }
 
     .history-dropdown-button:hover {
-      opacity: 0.8;
+      background: var(--vscode-toolbar-hoverBackground);
     }
 
     .dropdown-label {
@@ -111,6 +173,10 @@ export function getConversationHistoryBarStyles(): string {
       cursor: pointer;
       transition: background 0.2s ease;
       border-bottom: 1px solid var(--vscode-panel-border);
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 12px;
     }
 
     .history-item:last-child {
@@ -124,15 +190,17 @@ export function getConversationHistoryBarStyles(): string {
     .history-item-title {
       font-size: 14px;
       font-weight: 500;
-      margin-bottom: 4px;
       white-space: nowrap;
       overflow: hidden;
       text-overflow: ellipsis;
+      flex: 1;
     }
 
     .history-item-time {
       font-size: 12px;
       opacity: 0.7;
+      white-space: nowrap;
+      flex-shrink: 0;
     }
 
     .history-empty {
@@ -142,6 +210,14 @@ export function getConversationHistoryBarStyles(): string {
       font-size: 14px;
     }
 
+    .history-load-more {
+      padding: 12px 16px;
+      text-align: center;
+      color: var(--vscode-descriptionForeground);
+      font-size: 12px;
+      border-top: 1px solid var(--vscode-panel-border);
+    }
+
     .new-conversation-button {
       width: 36px;
       height: 36px;
@@ -149,7 +225,7 @@ export function getConversationHistoryBarStyles(): string {
       background: transparent;
       color: var(--vscode-foreground);
       border: none;
-      border-radius: 4px;
+      border-radius: 50%;
       cursor: pointer;
       display: flex;
       align-items: center;
@@ -159,11 +235,12 @@ export function getConversationHistoryBarStyles(): string {
     }
 
     .new-conversation-button:hover {
-      opacity: 0.7;
+      background: var(--vscode-toolbar-hoverBackground);
+      transform: scale(1.1);
     }
 
     .new-conversation-button:active {
-      opacity: 0.5;
+      transform: scale(0.95);
     }
 
     .new-conversation-button svg {
@@ -196,9 +273,38 @@ export function getConversationHistoryBarStyles(): string {
  */
 export function getConversationHistoryBarScript(): string {
   return `
+    ${getUserInfoComponentScript()}
+
+    // 更新用户头像图标按钮显示
+    function updateUserAvatarIconButton(userInfo) {
+      const userAvatarIconButton = document.getElementById('userAvatarIconButton');
+
+      if (userInfo && userInfo.nickname) {
+        // 显示用户头像图标按钮
+        if (userAvatarIconButton) {
+          userAvatarIconButton.style.display = 'flex';
+        }
+        // 同时更新用户详情弹窗的数据
+        if (typeof updateUserInfoDisplay === 'function') {
+          updateUserInfoDisplay(userInfo);
+        }
+      } else {
+        // 隐藏用户头像图标按钮
+        if (userAvatarIconButton) {
+          userAvatarIconButton.style.display = 'none';
+        }
+      }
+    }
+
     // 会话历史相关变量
     let conversationHistory = [];
     let currentConversationId = null;
+    let currentOffset = 0;
+    let totalHistory = 0;
+    let hasMoreHistory = false;
+    let isLoadingHistory = false;
+    const HISTORY_PAGE_SIZE = 10;
+    const MAX_HISTORY_ITEMS = 100;
 
     // 切换历史记录下拉菜单
     function toggleHistoryDropdown() {
@@ -211,33 +317,90 @@ export function getConversationHistoryBarScript(): string {
       } else {
         menu.classList.add('active');
         button.classList.add('active');
-        // 加载会话历史
+        // 重置并加载会话历史
-        loadConversationHistory();
+        resetAndLoadHistory();
       }
     }
 
-    // 加载会话历史
+    // 重置并加载会话历史
-    function loadConversationHistory() {
+    function resetAndLoadHistory() {
-      vscode.postMessage({ command: 'loadConversationHistory' });
+      conversationHistory = [];
+      currentOffset = 0;
+      totalHistory = 0;
+      hasMoreHistory = false;
+      const historyList = document.getElementById('historyList');
+      if (historyList) {
+        historyList.innerHTML = '<div class="history-empty">加载中...</div>';
+      }
+      loadMoreHistory();
     }
 
-    // 渲染会话历史列表
+    // 加载更多会话历史
-    function renderConversationHistory(history) {
+    function loadMoreHistory() {
-      conversationHistory = history;
+      if (isLoadingHistory || (currentOffset > 0 && !hasMoreHistory)) {
-      const historyList = document.getElementById('historyList');
+        return;
+      }
 
-      if (!history || history.length === 0) {
+      // 检查是否已达到最大数量
+      if (currentOffset >= MAX_HISTORY_ITEMS) {
+        return;
+      }
+
+      isLoadingHistory = true;
+      vscode.postMessage({
+        command: 'loadConversationHistory',
+        offset: currentOffset,
+        limit: HISTORY_PAGE_SIZE
+      });
+    }
+
+    // 渲染会话历史列表（支持追加）
+    function renderConversationHistory(data) {
+      isLoadingHistory = false;
+
+      if (!data || !data.items) {
+        return;
+      }
+
+      // 追加新数据
+      conversationHistory = conversationHistory.concat(data.items);
+      totalHistory = data.total;
+      hasMoreHistory = data.hasMore;
+      currentOffset += data.items.length;
+
+      const historyList = document.getElementById('historyList');
+      if (!historyList) {
+        return;
+      }
+
+      // 如果没有任何历史记录
+      if (conversationHistory.length === 0) {
         historyList.innerHTML = '<div class="history-empty">暂无会话历史</div>';
         return;
       }
 
-      historyList.innerHTML = history.map(item => \`
+      // 渲染所有历史记录
-        <div class="history-item"
+      historyList.innerHTML = conversationHistory.map(item => \`
-             onclick="selectConversation('\${item.id}')">
+        <div class="history-item" onclick="selectConversation('\${item.id}')">
           <div class="history-item-title">\${item.title || '未命名会话'}</div>
           <div class="history-item-time">\${formatTime(item.timestamp)}</div>
         </div>
       \`).join('');
+
+      // 如果还有更多数据，添加"加载更多"提示
+      if (hasMoreHistory && currentOffset < MAX_HISTORY_ITEMS) {
+        historyList.innerHTML += \`
+          <div class="history-load-more" id="loadMoreIndicator">
+            <span>滚动加载更多...</span>
+          </div>
+        \`;
+      } else if (currentOffset >= MAX_HISTORY_ITEMS && hasMoreHistory) {
+        historyList.innerHTML += \`
+          <div class="history-load-more">
+            <span>已显示最近 \${MAX_HISTORY_ITEMS} 条记录</span>
+          </div>
+        \`;
+      }
     }
 
     // 选择会话
@@ -291,6 +454,22 @@ export function getConversationHistoryBarScript(): string {
       });
     }
 
+    // 监听下拉菜单滚动事件
+    const historyDropdownMenu = document.getElementById('historyDropdownMenu');
+    if (historyDropdownMenu) {
+      historyDropdownMenu.addEventListener('scroll', () => {
+        const menu = historyDropdownMenu;
+        const scrollTop = menu.scrollTop;
+        const scrollHeight = menu.scrollHeight;
+        const clientHeight = menu.clientHeight;
+
+        // 当滚动到距离底部 50px 时，加载更多
+        if (scrollHeight - scrollTop - clientHeight < 50) {
+          loadMoreHistory();
+        }
+      });
+    }
+
     // 点击外部关闭下拉菜单
     document.addEventListener('click', (event) => {
       const container = document.querySelector('.history-dropdown-container');

src/views/inputArea.ts

@@ -0,0 +1,454 @@
+import { getWaveformPreviewContent } from "./waveformPreviewContent";
+import {
+  getModelSelectorContent,
+  getModelSelectorStyles,
+  getModelSelectorScript,
+} from "./modelSelector";
+import {
+  getModeSelectorContent,
+  getModeSelectorStyles,
+  getModeSelectorScript,
+} from "./agentModeSelector";
+import {
+  getContextButtonContent,
+  getContextButtonStyles,
+  getContextButtonScript,
+} from "./contextButton";
+import {
+  getContextDisplayContent,
+  getContextDisplayStyles,
+  getContextDisplayScript,
+} from "./contextDisplay";
+import {
+  getContextCompressContent,
+  getContextCompressStyles,
+  getContextCompressScript,
+} from "./contextCompress";
+import {
+  getOptimizeButtonContent,
+  getOptimizeButtonStyles,
+  getOptimizeButtonScript,
+} from "./optimizeButton";
+import { sendIconSvg, stopIconSvg } from "../constants/toolIcons";
+
+/**
+ * 获取输入区域的 HTML 内容
+ */
+export function getInputAreaContent(
+  autoIcon: string = '',
+  liteIcon: string = '',
+  syIcon: string = '',
+  maxIcon: string = ''
+): string {
+  return `
+    <div class="input-area centered" id="inputArea">
+      <div class="input-group">
+        <div class="input-wrapper">
+          <!-- 顶部工具栏 -->
+          <div class="input-top-toolbar">
+            ${getContextButtonContent()}
+          </div>
+          <!-- 上下文显示区域 -->
+          ${getContextDisplayContent()}
+          <textarea
+            id="messageInput"
+            placeholder="输入您的问题，按 Enter 发送，Shift + Enter 换行..."
+            onkeydown="if(event.key === 'Enter' && !event.shiftKey) { event.preventDefault(); sendMessage(); }"
+          ></textarea>
+          <div class="input-bottom-row">
+            <div class="mode-selector">
+              ${getModeSelectorContent()}
+              ${getModelSelectorContent(autoIcon, liteIcon, syIcon, maxIcon)}
+            </div>
+            <div class="input-actions">
+              ${getContextCompressContent()}
+              ${getOptimizeButtonContent()}
+              <button id="sendButton" onclick="handleSendOrStop()">
+                ${sendIconSvg}
+                <span style="display: none;">${stopIconSvg}</span>
+              </button>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+/**
+ * 获取输入区域的样式
+ */
+export function getInputAreaStyles(): string {
+  return `
+    ${getModeSelectorStyles()}
+    ${getModelSelectorStyles()}
+    ${getContextButtonStyles()}
+    ${getContextDisplayStyles()}
+    ${getContextCompressStyles()}
+    ${getOptimizeButtonStyles()}
+    .input-area {
+      border-top: 1px solid var(--vscode-panel-border);
+      padding-top: 15px;
+      flex-shrink: 0;
+      transition: all 0.3s ease;
+    }
+    /* 居中模式：未发起对话时 */
+    .input-area.centered {
+      position: absolute;
+      top: 50%;
+      left: 50%;
+      transform: translate(-50%, -50%);
+      width: calc(100% - 40px);
+      max-width: 800px;
+      border-top: none;
+      padding-top: 0;
+    }
+    /* 底部模式：发起对话后 */
+    .input-area.bottom {
+      position: relative;
+      transform: none;
+    }
+    .input-group {
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+      background: var(--vscode-input-background);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 8px;
+      padding: 12px;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15), 0 2px 6px rgba(0, 0, 0, 0.1);
+      transition: all 0.3s ease;
+    }
+    .input-group:hover {
+      box-shadow: 0 6px 16px rgba(0, 0, 0, 0.2), 0 3px 8px rgba(0, 0, 0, 0.15);
+    }
+    .input-group:focus-within {
+      border-color: var(--vscode-focusBorder);
+      box-shadow: 0 6px 20px rgba(0, 0, 0, 0.25), 0 3px 10px rgba(0, 0, 0, 0.2);
+    }
+    .input-wrapper {
+      display: flex;
+      flex-direction: column;
+      gap: 8px;
+      width: 100%;
+    }
+    /* 顶部工具栏样式 */
+    .input-top-toolbar {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      margin-bottom: 8px;
+      gap: 12px;
+    }
+    .input-bottom-row {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      gap: 10px;
+      margin-bottom: -17px;
+    }
+    .mode-selector {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      position: relative;
+    }
+    .input-actions {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+    }
+    /* Tooltip 样式 */
+    .tooltip {
+      position: relative;
+      display: inline-block;
+    }
+    .tooltip .tooltiptext {
+      visibility: hidden;
+      width: auto;
+      background: #1e1e1e;
+      color: #ffffff;
+      text-align: center;
+      border-radius: 6px;
+      padding: 6px 12px;
+      position: absolute;
+      z-index: 1000;
+      bottom: 150%;
+      left: 50%;
+      transform: translateX(-50%) translateY(10px);
+      opacity: 0;
+      transition: all 0.3s cubic-bezier(0.68, -0.55, 0.265, 1.55);
+      font-size: 12px;
+      font-weight: 500;
+      border: 1px solid rgba(255, 255, 255, 0.2);
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.6), 0 2px 4px rgba(0, 0, 0, 0.3);
+      white-space: nowrap;
+      letter-spacing: 0.3px;
+    }
+    .tooltip .tooltiptext::after {
+      content: "";
+      position: absolute;
+      top: 100%;
+      left: 50%;
+      margin-left: -6px;
+      border-width: 6px;
+      border-style: solid;
+      border-color: #1e1e1e transparent transparent transparent;
+    }
+    .tooltip .tooltiptext::before {
+      content: "";
+      position: absolute;
+      top: 100%;
+      left: 50%;
+      margin-left: -7px;
+      border-width: 7px;
+      border-style: solid;
+      border-color: rgba(255, 255, 255, 0.2) transparent transparent transparent;
+      z-index: -1;
+    }
+    .tooltip:hover .tooltiptext {
+      visibility: visible;
+      opacity: 1;
+      transform: translateX(-50%) translateY(0);
+    }
+    textarea {
+      width: 100%;
+      padding: 10px;
+      background: transparent;
+      color: var(--vscode-input-foreground);
+      border: none;
+      border-radius: 4px;
+      font-family: inherit;
+      resize: none;
+      min-height: 40px;
+      max-height: 200px;
+      outline: none;
+      box-sizing: border-box;
+      overflow-y: auto;
+      line-height: 1.5;
+    }
+    textarea:disabled {
+      opacity: 0.5;
+      cursor: not-allowed;
+      background: rgba(128, 128, 128, 0.1);
+    }
+    /* 简洁的滚动条样式 */
+    textarea::-webkit-scrollbar {
+      width: 8px;
+    }
+    textarea::-webkit-scrollbar-track {
+      background: transparent;
+    }
+    textarea::-webkit-scrollbar-thumb {
+      background: rgba(128, 128, 128, 0.5);
+      border-radius: 4px;
+    }
+    textarea::-webkit-scrollbar-button {
+      display: none;
+    }
+    button {
+      padding: 0 20px;
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      transition: background 0.2s ease;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+    }
+    button:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+    /* 发送按钮状态样式 */
+    #sendButton {
+      position: relative;
+      min-width: 32px;
+      padding: 6px 8px;
+    }
+    #sendButton svg {
+      width: 14px;
+      height: 14px;
+      display: block;
+    }
+    #sendButton.sending {
+      background: var(--vscode-button-background);
+    }
+    #sendButton.sending:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+  `;
+}
+
+/**
+ * 获取输入区域的脚本
+ */
+export function getInputAreaScript(): string {
+  return `
+    // 注意：getModeSelectorScript() 已在 webviewContent.ts 开头加载，这里不再重复加载
+    ${getModelSelectorScript()}
+    ${getContextButtonScript()}
+    ${getContextDisplayScript()}
+    ${getContextCompressScript()}
+    ${getOptimizeButtonScript()}
+
+    // 对话状态管理
+    let isConversationActive = false;
+    let hasMessages = false; // 是否已有消息
+
+    // 工作区检测状态
+    let hasCheckedWorkspace = false; // 是否已经检测过工作区
+    let hasWorkspace = true; // 工作区状态
+
+    // 切换输入框布局模式
+    function updateInputAreaLayout() {
+      const inputArea = document.getElementById('inputArea');
+      if (!inputArea) return;
+
+      if (hasMessages) {
+        // 有消息时，移到底部
+        inputArea.classList.remove('centered');
+        inputArea.classList.add('bottom');
+      } else {
+        // 无消息时，居中显示
+        inputArea.classList.add('centered');
+        inputArea.classList.remove('bottom');
+      }
+    }
+
+    // 自动调整 textarea 高度
+    function autoResizeTextarea() {
+      if (messageInput) {
+        messageInput.style.height = 'auto';
+        messageInput.style.height = messageInput.scrollHeight + 'px';
+      }
+    }
+
+    // 监听输入事件，自动调整高度
+    if (messageInput) {
+      messageInput.addEventListener('input', autoResizeTextarea);
+
+      // 监听点击事件，检测工作区状态
+      messageInput.addEventListener('focus', () => {
+        if (!hasCheckedWorkspace) {
+          hasCheckedWorkspace = true;
+          vscode.postMessage({ command: 'checkWorkspace' });
+        }
+      });
+
+      // 初始化时调整一次高度
+      autoResizeTextarea();
+    }
+
+    // 切换发送按钮状态
+    function setSendButtonState(isSending) {
+      const sendButton = document.getElementById('sendButton');
+      const children = sendButton.children;
+      const sendIconContainer = children[0]; // 第一个子元素是发送图标的 SVG
+      const stopIconContainer = children[1]; // 第二个子元素是包含暂停图标的 span
+
+      if (isSending) {
+        sendButton.classList.add('sending');
+        sendIconContainer.style.display = 'none';
+        stopIconContainer.style.display = 'block';
+        isConversationActive = true;
+        // 禁用输入框
+        messageInput.disabled = true;
+        messageInput.placeholder = '正在处理中，请稍候...';
+      } else {
+        sendButton.classList.remove('sending');
+        sendIconContainer.style.display = 'block';
+        stopIconContainer.style.display = 'none';
+        isConversationActive = false;
+        // 启用输入框
+        messageInput.disabled = false;
+        messageInput.placeholder = '输入您的问题，按 Enter 发送，Shift + Enter 换行...';
+      }
+    }
+
+    // 处理发送或停止
+    function handleSendOrStop() {
+      if (isConversationActive) {
+        // 当前正在对话，执行停止操作
+        vscode.postMessage({ command: 'abortDialog' });
+        setSendButtonState(false);
+      } else {
+        // 当前未在对话，执行发送操作
+        sendMessage();
+      }
+    }
+
+    function sendMessage() {
+      const text = messageInput.value.trim();
+      if (!text) return;
+
+      // 如果正在对话中，阻止发送新消息
+      if (isConversationActive) {
+        return;
+      }
+
+      // 检查工作区状态
+      if (!hasWorkspace) {
+        // 如果没有工作区，阻止发送并清空输入框
+        messageInput.value = '';
+        autoResizeTextarea();
+        return;
+      }
+
+      const mode = getCurrentMode(); // 从模式选择器组件获取当前模式
+      const model = getCurrentModel(); // 从模型选择器组件获取当前模型
+      const planMode = document.getElementById('planToggle')?.checked || false;
+
+      // 获取上下文项
+      const contextItems = window.getContextItems ? window.getContextItems() : [];
+
+      addMessage(text, 'user');
+
+      // 标记已有消息，切换布局到底部
+      hasMessages = true;
+      updateInputAreaLayout();
+
+      // 切换按钮为暂停状态
+      setSendButtonState(true);
+
+      vscode.postMessage({
+        command: 'sendMessage',
+        text: text,
+        mode: mode,
+        model: model,
+        planMode: planMode,
+        contextItems: contextItems
+      });
+      messageInput.value = '';
+      autoResizeTextarea(); // 重置输入框高度
+      messageInput.focus();
+
+      // 重置优化状态
+      resetOptimizeButton();
+    }
+
+    // 全局函数：重置输入框布局（用于清空对话时）
+    window.resetInputAreaLayout = function() {
+      hasMessages = false;
+      updateInputAreaLayout();
+    };
+
+    // 全局函数：检查是否有消息（用于页面加载时）
+    window.checkMessagesAndUpdateLayout = function() {
+      const messagesContainer = document.getElementById('messages');
+      if (messagesContainer) {
+        const messageElements = messagesContainer.querySelectorAll('.message');
+        hasMessages = messageElements.length > 0;
+        updateInputAreaLayout();
+      }
+    };
+
+    // 页面加载时检查消息状态
+    setTimeout(() => {
+      if (window.checkMessagesAndUpdateLayout) {
+        window.checkMessagesAndUpdateLayout();
+      }
+    }, 100);
+  `;
+}

src/views/modelSelector.ts

@@ -0,0 +1,233 @@
+/**
+ * 模型选择器组件
+ */
+
+/**
+ * 获取模型选择器的 HTML 内容
+ */
+export function getModelSelectorContent(
+  autoIcon: string = "",
+  liteIcon: string = "",
+  syIcon: string = "",
+  maxIcon: string = ""
+): string {
+  return `
+    <!-- 模型选择 -->
+    <div class="tooltip">
+      <div class="custom-select" id="modelSelect">
+        <div class="select-trigger" onclick="toggleModelDropdown()">
+          <span class="select-value" id="modelValue">Auto</span>
+          <svg class="select-arrow" viewBox="0 0 1024 1024" xmlns="http://www.w3.org/2000/svg">
+            <path d="M507.8 727.728a30.016 30.016 0 0 1-21.288-8.824L231.104 463.496a30.088 30.088 0 0 1 0-42.568 30.088 30.088 0 0 1 42.568 0l234.128 234.128 234.16-234.128a30.088 30.088 0 0 1 42.568 0 30.088 30.088 0 0 1 0 42.568L529.08 718.904a30 30 0 0 1-21.28 8.824z" fill="#8a8a8a"/>
+          </svg>
+        </div>
+        <div class="select-dropdown" id="modelDropdown">
+          <div class="select-option selected" data-value="auto" onclick="selectModel('auto', 'Auto')">
+            ${
+              autoIcon
+                ? `<img src="${autoIcon}" class="model-icon" alt="Auto">`
+                : ""
+            }
+            <div class="option-content">
+              <span class="option-label">Auto</span>
+              <span class="option-desc">智能匹配最优模型</span>
+            </div>
+          </div>
+          <div class="select-option" data-value="lite" onclick="selectModel('lite', 'Lite')">
+            ${
+              liteIcon
+                ? `<img src="${liteIcon}" class="model-icon" alt="Lite">`
+                : ""
+            }
+            <div class="option-content">
+              <span class="option-label">Lite</span>
+              <span class="option-desc">基础模型，快速相应，适合简单任务</span>
+            </div>
+          </div>
+          <div class="select-option" data-value="syntaxic" onclick="selectModel('syntaxic', 'Syntaxic')">
+            ${
+              syIcon
+                ? `<img src="${syIcon}" class="model-icon" alt="Syntaxic">`
+                : ""
+            }
+            <div class="option-content">
+              <span class="option-label">Syntaxic</span>
+              <span class="option-desc">均衡成本和性能，节省credits同时保持可靠输出</span>
+            </div>
+          </div>
+          <div class="select-option" data-value="max" onclick="selectModel('max', 'Max')">
+            ${
+              maxIcon
+                ? `<img src="${maxIcon}" class="model-icon" alt="Max">`
+                : ""
+            }
+            <div class="option-content">
+              <span class="option-label">Max</span>
+              <span class="option-desc">最强性能，质量优先，适合复杂任务</span>
+            </div>
+          </div>
+        </div>
+      </div>
+      <span class="tooltiptext">选择模型</span>
+    </div>
+  `;
+}
+
+/**
+ * 获取模型选择器的样式
+ */
+export function getModelSelectorStyles(): string {
+  return `
+    /* 自定义下拉框样式 */
+    .custom-select {
+      position: relative;
+      user-select: none;
+    }
+    .select-trigger {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      padding: 4px 8px;
+      background: var(--vscode-input-background);
+      color: var(--vscode-foreground);
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 12px;
+      transition: background 0.2s ease;
+    }
+    .select-trigger:hover {
+      background: var(--vscode-list-hoverBackground);
+    }
+    .select-value {
+      white-space: nowrap;
+    }
+    .select-arrow {
+      width: 12px;
+      height: 12px;
+      flex-shrink: 0;
+      transition: transform 0.2s ease;
+    }
+    .custom-select.active .select-arrow {
+      transform: rotate(180deg);
+    }
+    .select-dropdown {
+      position: absolute;
+      bottom: calc(100% + 2px);
+      left: 0;
+      min-width: 100%;
+      background: var(--vscode-dropdown-background);
+      border: 1px solid var(--vscode-dropdown-border);
+      border-radius: 4px;
+      box-shadow: 0 4px 12px rgba(0, 0, 0, 0.15);
+      z-index: 1100;
+      display: none;
+      overflow: visible;
+    }
+    .custom-select.active .select-dropdown {
+      display: block;
+    }
+    /* 模型选择器的选项样式 */
+    #modelDropdown .select-option {
+      position: relative;
+      padding: 8px 12px;
+      cursor: pointer;
+      transition: background 0.2s ease;
+      display: flex;
+      flex-direction: row;
+      align-items: center;
+      gap: 10px;
+    }
+    #modelDropdown .select-option:hover {
+      background: rgba(128, 128, 128, 0.3);
+    }
+    #modelDropdown .select-option.selected {
+      background: rgba(128, 128, 128, 0.5);
+      color: var(--vscode-foreground);
+    }
+    .model-icon {
+      width: 16px;
+      height: 16px;
+      flex-shrink: 0;
+      object-fit: contain;
+    }
+    .option-content {
+      display: flex;
+      flex-direction: column;
+      gap: 2px;
+      flex: 1;
+    }
+    .option-label {
+      font-size: 13px;
+      color: var(--vscode-foreground);
+      font-weight: 500;
+      white-space: nowrap;
+    }
+    .option-desc {
+      font-size: 11px;
+      color: var(--vscode-descriptionForeground);
+      white-space: nowrap;
+    }
+  `;
+}
+
+/**
+ * 获取模型选择器的脚本
+ */
+export function getModelSelectorScript(): string {
+  return `
+    // 模型选择相关变量
+    let currentModel = 'auto';
+
+    // 切换模型下拉框显示/隐藏
+    function toggleModelDropdown() {
+      const modelSelect = document.getElementById('modelSelect');
+      const customSelect = document.getElementById('customSelect');
+      if (modelSelect) {
+        modelSelect.classList.toggle('active');
+        // 关闭模式下拉框
+        if (customSelect) {
+          customSelect.classList.remove('active');
+        }
+      }
+    }
+
+    // 选择模型
+    function selectModel(value, label) {
+      currentModel = value;
+      const modelValue = document.getElementById('modelValue');
+      if (modelValue) {
+        modelValue.textContent = label;
+      }
+
+      // 更新选中状态
+      const options = document.querySelectorAll('#modelDropdown .select-option');
+      options.forEach(option => {
+        if (option.getAttribute('data-value') === value) {
+          option.classList.add('selected');
+        } else {
+          option.classList.remove('selected');
+        }
+      });
+
+      // 关闭下拉框
+      const modelSelect = document.getElementById('modelSelect');
+      if (modelSelect) {
+        modelSelect.classList.remove('active');
+      }
+    }
+
+    // 点击外部关闭模型下拉框
+    document.addEventListener('click', (event) => {
+      const modelSelect = document.getElementById('modelSelect');
+      if (modelSelect && !modelSelect.contains(event.target)) {
+        modelSelect.classList.remove('active');
+      }
+    });
+
+    // 获取当前选中的模型
+    function getCurrentModel() {
+      return currentModel;
+    }
+  `;
+}

src/views/optimizeButton.ts

@@ -0,0 +1,117 @@
+/**
+ * 一键优化按钮组件
+ */
+
+/**
+ * 获取一键优化按钮的 HTML 内容
+ */
+export function getOptimizeButtonContent(): string {
+  return `
+    <!-- 一键优化按钮 -->
+    <div class="tooltip">
+      <button id="optimizeButton" class="optimize-button" onclick="handleOptimize()">
+        <svg t="1765867478136" id="optimizeIcon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="2314"><path d="M490.048929 399.773864c7.042381-21.120144 36.85976-21.120144 43.902142 0l41.273372 123.957105A184.967743 184.967743 0 0 0 692.274156 640.713687l123.890111 41.273373c21.119144 7.042381 21.119144 36.85976 0 43.902141L692.207161 767.162574A184.967743 184.967743 0 0 0 575.224443 884.212286l-41.273372 123.890111A23.09997 23.09997 0 0 1 512 1024c-9.983123 0-18.838344-6.409437-21.951071-15.897603L448.775557 884.145292A184.946745 184.946745 0 0 0 331.792839 767.162574L207.836733 725.889201A23.09997 23.09997 0 0 1 191.93813 703.93813c0-9.983123 6.409437-18.838344 15.897603-21.95107l123.957106-41.273373A184.946745 184.946745 0 0 0 448.775557 523.730969zM242.840657 73.466543A13.888779 13.888779 0 0 1 256.022498 63.94338c5.987474 0 11.299007 3.839663 13.182841 9.523163l24.767824 74.360464a111.070238 111.070238 0 0 0 70.19983 70.20083l74.360464 24.767824A13.888779 13.888779 0 0 1 448.05662 255.977502c0 5.987474-3.839663 11.299007-9.523163 13.182841l-74.360464 24.767823a110.947249 110.947249 0 0 0-70.20083 70.199831l-24.767824 74.360464A13.888779 13.888779 0 0 1 256.022498 448.011624a13.888779 13.888779 0 0 1-13.182841-9.523163l-24.767823-74.360464a110.947249 110.947249 0 0 0-70.199831-70.20083l-74.360464-24.767824A13.888779 13.888779 0 0 1 63.988376 255.977502c0-5.987474 3.839663-11.299007 9.523163-13.182841l74.360464-24.767824a110.947249 110.947249 0 0 0 70.20083-70.19983zM695.213897 6.335443a9.283184 9.283184 0 0 1 17.538459 0L729.260905 55.86509a73.889506 73.889506 0 0 0 46.843883 46.843883l49.530646 16.509549a9.283184 9.283184 0 0 1 0 17.538458L776.106787 153.266529a73.9585 73.9585 0 0 0-46.843882 46.843883l-16.509549 49.530647a9.283184 9.283184 0 0 1-17.538459 0L678.705348 200.112412a73.9585 73.9585 0 0 0-46.843883-46.843883l-49.468652-16.509549a9.283184 9.283184 0 0 1 0-17.538458l49.535646-16.509549a73.897505 73.897505 0 0 0 46.842883-46.843883L695.213897 6.397438z m0 0" p-id="2315" fill="#409eff"></path></svg>
+      </button>
+      <span class="tooltiptext" id="optimizeTooltip">一键优化</span>
+    </div>
+  `;
+}
+
+/**
+ * 获取一键优化按钮的样式
+ */
+export function getOptimizeButtonStyles(): string {
+  return `
+    /* 一键优化按钮样式 */
+    .optimize-button {
+      padding: 8px;
+      background: transparent;
+      color: var(--vscode-foreground);
+      border: none;
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: opacity 0.2s ease;
+      width: 32px;
+      height: 32px;
+    }
+
+    .optimize-button:hover {
+      opacity: 0.7;
+    }
+
+    .optimize-button svg {
+      width: 16px;
+      height: 16px;
+    }
+
+    .optimize-button-wrapper {
+      display: flex;
+      align-items: flex-end;
+    }
+  `;
+}
+
+/**
+ * 获取一键优化按钮的脚本
+ */
+export function getOptimizeButtonScript(): string {
+  return `
+    let isOptimized = false; // 标记是否已优化
+    let originalText = ''; // 保存原始文本用于撤回
+
+    function handleOptimize() {
+      if (isOptimized) {
+        // 撤回操作
+        messageInput.value = originalText;
+        resetOptimizeButton();
+      } else {
+        // 优化操作
+        originalText = messageInput.value; // 保存原始文本
+
+        // 使用死数据替换输入框内容
+        const optimizedTexts = [
+          '请帮我优化这段代码，提高性能和可读性',
+          '请分析这个问题并给出最佳解决方案',
+          '请帮我重构这段代码，使其更加简洁高效',
+          '请检查代码中的潜在问题并提供改进建议'
+        ];
+        const randomText = optimizedTexts[Math.floor(Math.random() * optimizedTexts.length)];
+        messageInput.value = randomText;
+
+        // 切换到撤回状态
+        isOptimized = true;
+        updateOptimizeButton();
+      }
+
+      messageInput.focus();
+      autoResizeTextarea();
+    }
+
+    function updateOptimizeButton() {
+      const optimizeIcon = document.getElementById('optimizeIcon');
+      const optimizeTooltip = document.getElementById('optimizeTooltip');
+
+      if (optimizeIcon && optimizeTooltip) {
+        // 切换为撤回图标
+        optimizeIcon.innerHTML = '<path d="M581.056 288.32H232.96l108.352-102.208c15.552-15.744 19.456-31.104 4.16-46.208-16.064-15.872-32.576-15.808-48.64 0l-145.92 144.768c-8.768 8.832-23.488 20.608-22.08 32.448l0.64 4.8-0.64 4.864c-1.344 11.776 6.4 18.24 14.848 26.816l147.648 145.216c16.064 15.808 38.08 20.992 54.144 5.12 15.296-15.104 3.84-38.208-11.328-53.504L233.152 353.6 581.056 352c126.464 0 250.944 111.488 250.944 236.16C832 712.832 707.52 832 581.056 832H246.4c-22.592 0-29.696 9.6-29.696 32.256s7.04 31.744 29.696 31.744H581.12C755.136 896 896 757.696 896 588.16c0-169.408-140.8-299.84-314.944-299.84z" fill="currentColor"/><path d="M323.392 192a32 32 0 1 1 0-64 32 32 0 0 1 0 64zM320.192 514.048a32 32 0 1 1 0-64 32 32 0 0 1 0 64zM237.824 896a32 32 0 1 1 0-64 32 32 0 0 1 0 64z" fill="currentColor"/>';
+        optimizeTooltip.textContent = '撤回';
+      }
+    }
+
+    function resetOptimizeButton() {
+      const optimizeIcon = document.getElementById('optimizeIcon');
+      const optimizeTooltip = document.getElementById('optimizeTooltip');
+
+      if (optimizeIcon && optimizeTooltip) {
+        // 切换回优化图标（星星图标）
+        optimizeIcon.innerHTML = '<path d="M490.048929 399.773864c7.042381-21.120144 36.85976-21.120144 43.902142 0l41.273372 123.957105A184.967743 184.967743 0 0 0 692.274156 640.713687l123.890111 41.273373c21.119144 7.042381 21.119144 36.85976 0 43.902141L692.207161 767.162574A184.967743 184.967743 0 0 0 575.224443 884.212286l-41.273372 123.890111A23.09997 23.09997 0 0 1 512 1024c-9.983123 0-18.838344-6.409437-21.951071-15.897603L448.775557 884.145292A184.946745 184.946745 0 0 0 331.792839 767.162574L207.836733 725.889201A23.09997 23.09997 0 0 1 191.93813 703.93813c0-9.983123 6.409437-18.838344 15.897603-21.95107l123.957106-41.273373A184.946745 184.946745 0 0 0 448.775557 523.730969zM242.840657 73.466543A13.888779 13.888779 0 0 1 256.022498 63.94338c5.987474 0 11.299007 3.839663 13.182841 9.523163l24.767824 74.360464a111.070238 111.070238 0 0 0 70.19983 70.20083l74.360464 24.767824A13.888779 13.888779 0 0 1 448.05662 255.977502c0 5.987474-3.839663 11.299007-9.523163 13.182841l-74.360464 24.767823a110.947249 110.947249 0 0 0-70.20083 70.199831l-24.767824 74.360464A13.888779 13.888779 0 0 1 256.022498 448.011624a13.888779 13.888779 0 0 1-13.182841-9.523163l-24.767823-74.360464a110.947249 110.947249 0 0 0-70.199831-70.20083l-74.360464-24.767824A13.888779 13.888779 0 0 1 63.988376 255.977502c0-5.987474 3.839663-11.299007 9.523163-13.182841l74.360464-24.767824a110.947249 110.947249 0 0 0 70.20083-70.19983zM695.213897 6.335443a9.283184 9.283184 0 0 1 17.538459 0L729.260905 55.86509a73.889506 73.889506 0 0 0 46.843883 46.843883l49.530646 16.509549a9.283184 9.283184 0 0 1 0 17.538458L776.106787 153.266529a73.9585 73.9585 0 0 0-46.843882 46.843883l-16.509549 49.530647a9.283184 9.283184 0 0 1-17.538459 0L678.705348 200.112412a73.9585 73.9585 0 0 0-46.843883-46.843883l-49.468652-16.509549a9.283184 9.283184 0 0 1 0-17.538458l49.535646-16.509549a73.897505 73.897505 0 0 0 46.842883-46.843883L695.213897 6.397438z m0 0" fill="#409eff"/>';
+        optimizeTooltip.textContent = '一键优化';
+      }
+
+      isOptimized = false;
+      originalText = '';
+    }
+  `;
+}

src/views/planCard.ts

@@ -0,0 +1,293 @@
+/**
+ * 计划卡片组件
+ *
+ * 功能说明:
+ * - 显示执行计划的卡片界面
+ * - 包含计划标题、摘要和步骤列表
+ * - 提供确认执行、修改计划、取消等操作按钮
+ */
+
+import { plannerIconSvg } from "../constants/toolIcons";
+
+/**
+ * 获取计划卡片的样式
+ */
+export function getPlanCardStyles(): string {
+  return `
+    /* 计划卡片样式 */
+    .segment-plan {
+      margin: 12px 0;
+    }
+    .plan-card {
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 8px;
+      overflow: hidden;
+      background: var(--vscode-editor-background);
+    }
+    .plan-header {
+      display: flex;
+      align-items: center;
+      gap: 10px;
+      padding: 12px 16px;
+      background: var(--vscode-sideBar-background);
+      border-bottom: 1px solid var(--vscode-input-border);
+    }
+    .plan-icon {
+      font-size: 18px;
+    }
+    .plan-title {
+      font-weight: 600;
+      font-size: 14px;
+    }
+    .plan-body {
+      padding: 16px;
+    }
+    .plan-summary {
+      color: var(--vscode-descriptionForeground);
+      margin-bottom: 12px;
+      font-size: 13px;
+      line-height: 1.5;
+    }
+    .plan-steps {
+      font-size: 13px;
+    }
+    .plan-step {
+      padding: 8px 12px;
+      margin-bottom: 6px;
+      background: var(--vscode-list-hoverBackground);
+      border-radius: 4px;
+      line-height: 1.5;
+    }
+    .plan-step:last-child {
+      margin-bottom: 0;
+    }
+    .step-checkbox {
+      display: inline-flex;
+      align-items: center;
+      justify-content: center;
+      width: 16px;
+      height: 16px;
+      margin-right: 8px;
+      border: 2px solid var(--vscode-textLink-foreground);
+      border-radius: 4px;
+      background: transparent;
+      flex-shrink: 0;
+      opacity: 0.6;
+      transition: all 0.2s ease;
+    }
+    .step-checkbox.completed {
+      background: var(--vscode-textLink-foreground);
+      border-color: var(--vscode-textLink-foreground);
+      opacity: 1;
+    }
+    .step-checkbox.completed::after {
+      content: '✓';
+      color: var(--vscode-editor-background);
+      font-size: 11px;
+      font-weight: bold;
+    }
+    .plan-actions {
+      display: flex;
+      flex-direction: column;
+      gap: 10px;
+      padding: 14px 16px;
+      border-top: 1px solid var(--vscode-input-border);
+      background: var(--vscode-sideBar-background);
+    }
+    .plan-actions .question-options {
+      display: flex;
+      flex-wrap: wrap;
+      gap: 8px;
+    }
+    .plan-btn {
+      padding: 8px 18px;
+      border-radius: 4px;
+      border: none;
+      cursor: pointer;
+      font-size: 12px;
+      font-weight: 500;
+    }
+    .plan-btn-confirm {
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+    }
+    .plan-btn-confirm:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+    .plan-btn-modify {
+      background: var(--vscode-input-background);
+      color: var(--vscode-foreground);
+      border: 1px solid var(--vscode-input-border);
+    }
+    .plan-btn-cancel {
+      background: transparent;
+      color: var(--vscode-descriptionForeground);
+    }
+    .plan-actions .custom-input-container {
+      display: flex;
+      gap: 8px;
+      width: 100%;
+    }
+    .plan-actions .custom-input {
+      flex: 1;
+      padding: 8px 12px;
+      background: var(--vscode-input-background);
+      color: var(--vscode-input-foreground);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 4px;
+      font-size: 13px;
+    }
+    .plan-actions .custom-submit {
+      padding: 8px 18px;
+      background: var(--vscode-button-background);
+      color: var(--vscode-button-foreground);
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 12px;
+      font-weight: 500;
+    }
+    .plan-actions .custom-submit:hover {
+      background: var(--vscode-button-hoverBackground);
+    }
+  `;
+}
+
+/**
+ * 获取计划卡片的脚本
+ */
+export function getPlanCardScript(): string {
+  return `
+    // 渲染计划卡片（在 updateSegmentsRealtime 中使用）
+    function renderPlanCardInSegment(segment, segmentDiv, answeredQuestions) {
+      segmentDiv.className += ' segment-plan';
+
+      // 检查是否已回答
+      const isAnswered = answeredQuestions.has(segment.askId);
+      const selectedAnswer = answeredQuestions.get(segment.askId);
+
+      if (isAnswered) {
+        segmentDiv.classList.add('answered');
+      }
+
+      const stepsHtml = (segment.planSteps || []).map((step, i) =>
+        \`<div class="plan-step"><span class="step-checkbox"></span> \${step}</div>\`
+      ).join('');
+
+      // 选项按钮
+      const options = ['确认执行', '修改计划', '取消'];
+      const optionsHtml = options.map(opt => {
+        const isSelected = isAnswered && opt === selectedAnswer;
+        return \`<button class="question-option\${isSelected ? ' selected' : ''}" data-option="\${opt}">\${opt}</button>\`;
+      }).join('');
+
+      segmentDiv.innerHTML = \`
+        <div class="plan-card">
+          <div class="plan-header">
+            <span class="plan-icon">${plannerIconSvg}</span>
+            <span class="plan-title">\${segment.planTitle || '执行计划'}</span>
+          </div>
+          <div class="plan-body">
+            <div class="plan-summary">\${segment.planSummary || ''}</div>
+            <div class="plan-steps">\${stepsHtml}</div>
+          </div>
+          <div class="plan-actions">
+            <div class="question-options" data-ask-id="\${segment.askId}">\${optionsHtml}</div>
+            <div class="custom-input-container" style="display: \${isAnswered ? 'none' : 'flex'};">
+              <input type="text" class="custom-input" placeholder="输入修改建议..." />
+              <button class="custom-submit">提交</button>
+            </div>
+          </div>
+        </div>
+      \`;
+
+      // 只在未回答时添加事件监听
+      if (!isAnswered) {
+        setTimeout(() => {
+          const optionButtons = segmentDiv.querySelectorAll('.question-option');
+          optionButtons.forEach(btn => {
+            btn.addEventListener('click', function() {
+              const option = this.getAttribute('data-option');
+              // 发送答案到后端
+              handleQuestionAnswerInSegment(segment.askId, option, segmentDiv);
+              // 同时发送 planAction 用于模式切换
+              const actionMap = {
+                '确认执行': 'confirm',
+                '修改计划': 'modify',
+                '取消': 'cancel'
+              };
+              vscode.postMessage({
+                command: 'planAction',
+                action: actionMap[option] || option,
+                planTitle: segment.planTitle
+              });
+            });
+          });
+
+          const submitBtn = segmentDiv.querySelector('.custom-submit');
+          const customInput = segmentDiv.querySelector('.custom-input');
+          if (submitBtn && customInput) {
+            submitBtn.addEventListener('click', function() {
+              const customValue = customInput.value.trim();
+              if (customValue) {
+                handleQuestionAnswerInSegment(segment.askId, customValue, segmentDiv);
+              }
+            });
+
+            customInput.addEventListener('keypress', function(e) {
+              if (e.key === 'Enter') {
+                const customValue = customInput.value.trim();
+                if (customValue) {
+                  handleQuestionAnswerInSegment(segment.askId, customValue, segmentDiv);
+                }
+              }
+            });
+          }
+        }, 0);
+      }
+    }
+
+    // 渲染计划卡片（在 renderSegments 中使用）
+    function renderPlanCardStatic(segment, segmentDiv) {
+      segmentDiv.className += ' segment-plan';
+      const stepsHtml = (segment.planSteps || []).map((step, i) =>
+        \`<div class="plan-step"><span class="step-checkbox"></span> \${step}</div>\`
+      ).join('');
+
+      segmentDiv.innerHTML = \`
+        <div class="plan-card">
+          <div class="plan-header">
+            <span class="plan-icon">📋</span>
+            <span class="plan-title">\${segment.planTitle || '执行计划'}</span>
+          </div>
+          <div class="plan-body">
+            <div class="plan-summary">\${segment.planSummary || ''}</div>
+            <div class="plan-steps">\${stepsHtml}</div>
+          </div>
+          <div class="plan-actions">
+            <button class="plan-btn plan-btn-confirm" data-action="confirm">确认执行</button>
+            <button class="plan-btn plan-btn-modify" data-action="modify">修改计划</button>
+            <button class="plan-btn plan-btn-cancel" data-action="cancel">取消</button>
+          </div>
+        </div>
+      \`;
+
+      // 绑定按钮事件
+      setTimeout(() => {
+        const planCard = segmentDiv.querySelector('.plan-card');
+        if (planCard) {
+          planCard.querySelectorAll('.plan-btn').forEach(btn => {
+            btn.addEventListener('click', (e) => {
+              const action = e.currentTarget?.dataset?.action;
+              vscode.postMessage({
+                command: 'planAction',
+                action: action,
+                planTitle: segment.planTitle
+              });
+            });
+          });
+        }
+      }, 0);
+    }
+  `;
+}

src/views/planToggle.ts

@@ -0,0 +1,113 @@
+/**
+ * Plan 开关组件
+ * 注意：功能已移至模式选择器，此组件仅保留样式（已禁用）
+ */
+
+/**
+ * 获取 Plan 开关的 HTML 内容
+ * 已禁用，仅保留样式展示
+ */
+export function getPlanToggleContent(): string {
+  return `
+    <div class="tooltip">
+      <label class="plan-toggle plan-toggle-disabled">
+        <input type="checkbox" id="planToggle" disabled>
+        <span class="plan-toggle-slider"></span>
+        <span class="plan-toggle-label">Plan</span>
+      </label>
+      <span class="tooltiptext" id="planTooltip">请使用模式选择器切换 Plan 模式</span>
+    </div>
+  `;
+}
+
+/**
+ * 获取 Plan 开关的样式
+ */
+export function getPlanToggleStyles(): string {
+  return `
+    /* Plan 开关样式 */
+    .plan-toggle {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      cursor: pointer;
+      user-select: none;
+    }
+
+    .plan-toggle input[type="checkbox"] {
+      display: none;
+    }
+
+    .plan-toggle-slider {
+      position: relative;
+      width: 36px;
+      height: 20px;
+      background: var(--vscode-input-background);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 10px;
+      transition: all 0.3s ease;
+    }
+
+    .plan-toggle-slider::before {
+      content: "";
+      position: absolute;
+      width: 14px;
+      height: 14px;
+      left: 2px;
+      top: 2px;
+      background: var(--vscode-foreground);
+      border-radius: 50%;
+      transition: all 0.3s ease;
+    }
+
+    .plan-toggle input[type="checkbox"]:checked + .plan-toggle-slider {
+      background: #409eff;
+      border-color: #409eff;
+    }
+
+    .plan-toggle input[type="checkbox"]:checked + .plan-toggle-slider::before {
+      transform: translateX(16px);
+      background: white;
+    }
+
+    .plan-toggle-label {
+      font-size: 13px;
+      font-weight: 500;
+      color: var(--vscode-foreground);
+    }
+
+    /* 禁用状态样式 */
+    .plan-toggle-disabled {
+      cursor: not-allowed;
+      opacity: 0.5;
+    }
+
+    .plan-toggle-disabled .plan-toggle-slider {
+      background: var(--vscode-input-background);
+      border-color: var(--vscode-input-border);
+    }
+  `;
+}
+
+/**
+ * 获取 Plan 开关的脚本
+ */
+export function getPlanToggleScript(): string {
+  return `
+    // Plan 开关处理函数
+    function handlePlanToggle() {
+      const planToggle = document.getElementById('planToggle');
+      const planTooltip = document.getElementById('planTooltip');
+
+      if (planToggle && planTooltip) {
+        if (planToggle.checked) {
+          // 开启 Plan 模式
+          planTooltip.textContent = '关闭 Plan 模式';
+        } else {
+          // 关闭 Plan 模式
+          planTooltip.textContent = '启用 Plan 模式';
+        }
+      }
+    }
+  `;
+}

src/views/progressBar.ts

@@ -0,0 +1,411 @@
+/**
+ * 进度条模块
+ *
+ * 功能说明:
+ * - 显示开发流程进度: Spec -> Design代码编写 -> 仿真检查 -> AST -> Done
+ * - 支持动态更新当前进度状态
+ * - 提供视觉反馈显示已完成和进行中的步骤
+ */
+
+/**
+ * 获取进度条的 HTML 内容
+ */
+export function getProgressBarContent(): string {
+  return `
+    <div class="progress-bar-container" style="display: none;">
+      <div class="progress-bar-header">
+        <span class="progress-bar-title">开发流程</span>
+        <button class="progress-bar-toggle" title="收起/展开">
+          <span class="toggle-icon">▼</span>
+        </button>
+      </div>
+      <div class="progress-steps">
+        <div class="progress-step" data-step="spec">
+          <div class="step-circle">
+            <span class="step-number">1</span>
+            <span class="step-check">✓</span>
+          </div>
+          <div class="step-label">Spec</div>
+        </div>
+
+        <div class="progress-line"></div>
+
+        <div class="progress-step" data-step="design">
+          <div class="step-circle">
+            <span class="step-number">2</span>
+            <span class="step-check">✓</span>
+          </div>
+          <div class="step-label">Design</div>
+        </div>
+
+        <div class="progress-line"></div>
+
+        <div class="progress-step" data-step="simulation">
+          <div class="step-circle">
+            <span class="step-number">3</span>
+            <span class="step-check">✓</span>
+          </div>
+          <div class="step-label">Simulation</div>
+        </div>
+
+        <div class="progress-line"></div>
+
+        <div class="progress-step" data-step="done">
+          <div class="step-circle">
+            <span class="step-number">4</span>
+            <span class="step-check">✓</span>
+          </div>
+          <div class="step-label">Done</div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+/**
+ * 获取进度条的样式
+ */
+export function getProgressBarStyles(): string {
+  return `
+    .progress-bar-container {
+      background: var(--vscode-editor-background);
+      border-bottom: 1px solid var(--vscode-panel-border);
+      margin-bottom: 5px;
+    }
+
+    .progress-bar-header {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      padding: 8px 20px;
+      cursor: pointer;
+      user-select: none;
+    }
+
+    .progress-bar-title {
+      font-size: 11px;
+      font-weight: 600;
+      color: var(--vscode-foreground);
+    }
+
+    .progress-bar-toggle {
+      background: none;
+      border: none;
+      color: var(--vscode-foreground);
+      cursor: pointer;
+      padding: 2px 6px;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      opacity: 0.7;
+      transition: opacity 0.2s;
+    }
+
+    .progress-bar-toggle:hover {
+      opacity: 1;
+    }
+
+    .toggle-icon {
+      font-size: 10px;
+      transition: transform 0.3s ease;
+    }
+
+    .progress-bar-container.collapsed .toggle-icon {
+      transform: rotate(-90deg);
+    }
+
+    .progress-steps {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      max-width: 700px;
+      margin: 0 auto;
+      padding: 0 20px 10px 20px;
+      max-height: 60px;
+      overflow: hidden;
+      transition: max-height 0.3s ease, padding 0.3s ease;
+    }
+
+    .progress-bar-container.collapsed .progress-steps {
+      max-height: 0;
+      padding: 0 20px;
+    }
+
+    .progress-step {
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      position: relative;
+      flex: 0 0 auto;
+    }
+
+    .step-circle {
+      width: 24px;
+      height: 24px;
+      border-radius: 50%;
+      background: var(--vscode-input-background);
+      border: 2px solid var(--vscode-input-border);
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      position: relative;
+      transition: all 0.3s ease;
+      z-index: 2;
+    }
+
+    .step-number {
+      font-size: 10px;
+      font-weight: 600;
+      color: var(--vscode-foreground);
+    }
+
+    .step-check {
+      display: none;
+      font-size: 12px;
+      color: var(--vscode-button-foreground);
+    }
+
+    .step-label {
+      margin-top: 4px;
+      font-size: 10px;
+      color: var(--vscode-descriptionForeground);
+      text-align: center;
+      white-space: nowrap;
+      transition: color 0.3s ease;
+    }
+
+    .progress-line {
+      flex: 1;
+      height: 2px;
+      background: var(--vscode-input-border);
+      margin: 0 6px;
+      position: relative;
+      top: -10px;
+      transition: background 0.3s ease;
+    }
+
+    /* 已完成状态 */
+    .progress-step.completed .step-circle {
+      background: var(--vscode-button-background);
+      border-color: var(--vscode-button-background);
+    }
+
+    .progress-step.completed .step-number {
+      display: none;
+    }
+
+    .progress-step.completed .step-check {
+      display: block;
+    }
+
+    .progress-step.completed .step-label {
+      color: var(--vscode-foreground);
+      font-weight: 500;
+    }
+
+    .progress-step.completed + .progress-line {
+      background: var(--vscode-button-background);
+    }
+
+    /* 进行中状态 */
+    .progress-step.active .step-circle {
+      background: var(--vscode-button-background);
+      border-color: var(--vscode-button-background);
+      box-shadow: 0 0 0 2px var(--vscode-button-background)33;
+      animation: pulse 2s infinite;
+    }
+
+    .progress-step.active .step-number {
+      color: var(--vscode-button-foreground);
+    }
+
+    .progress-step.active .step-label {
+      color: var(--vscode-foreground);
+      font-weight: 600;
+    }
+
+    @keyframes pulse {
+      0%, 100% {
+        box-shadow: 0 0 0 2px var(--vscode-button-background)33;
+      }
+      50% {
+        box-shadow: 0 0 0 4px var(--vscode-button-background)1a;
+      }
+    }
+
+    /* 响应式设计 */
+    @media (max-width: 768px) {
+      .progress-steps {
+        flex-wrap: wrap;
+      }
+
+      .step-label {
+        font-size: 9px;
+      }
+
+      .step-circle {
+        width: 20px;
+        height: 20px;
+      }
+
+      .step-number {
+        font-size: 9px;
+      }
+
+      .progress-line {
+        margin: 0 4px;
+      }
+    }
+  `;
+}
+
+/**
+ * 获取进度条的脚本
+ */
+export function getProgressBarScript(): string {
+  return `
+    // 进度条管理
+    const ProgressBar = {
+      steps: ['spec', 'design', 'simulation', 'done'],
+      currentStep: 'spec',
+      isCollapsed: false,
+
+      /**
+       * 初始化进度条
+       */
+      init() {
+        this.updateProgress('spec');
+        this.initToggle();
+      },
+
+      /**
+       * 初始化收起/展开功能
+       */
+      initToggle() {
+        const container = document.querySelector('.progress-bar-container');
+        const header = document.querySelector('.progress-bar-header');
+        const toggle = document.querySelector('.progress-bar-toggle');
+
+        if (!container || !header || !toggle) return;
+
+        // 点击头部或按钮都可以切换
+        const handleToggle = (e) => {
+          e.stopPropagation();
+          this.isCollapsed = !this.isCollapsed;
+
+          if (this.isCollapsed) {
+            container.classList.add('collapsed');
+          } else {
+            container.classList.remove('collapsed');
+          }
+        };
+
+        header.addEventListener('click', handleToggle);
+        toggle.addEventListener('click', handleToggle);
+      },
+
+      /**
+       * 显示进度条
+       */
+      show() {
+        const container = document.querySelector('.progress-bar-container');
+        if (container) {
+          container.style.display = 'block';
+        }
+      },
+
+      /**
+       * 隐藏进度条
+       */
+      hide() {
+        const container = document.querySelector('.progress-bar-container');
+        if (container) {
+          container.style.display = 'none';
+        }
+      },
+
+      /**
+       * 更新进度到指定步骤
+       * @param {string} stepName - 步骤名称
+       */
+      updateProgress(stepName) {
+        if (!this.steps.includes(stepName)) {
+          console.warn('Invalid step name:', stepName);
+          return;
+        }
+
+        this.currentStep = stepName;
+        const currentIndex = this.steps.indexOf(stepName);
+
+        // 更新所有步骤的状态
+        document.querySelectorAll('.progress-step').forEach((step, index) => {
+          step.classList.remove('completed', 'active');
+
+          if (index < currentIndex) {
+            step.classList.add('completed');
+          } else if (index === currentIndex) {
+            step.classList.add('active');
+          }
+        });
+
+        // 更新连接线
+        document.querySelectorAll('.progress-line').forEach((line, index) => {
+          if (index < currentIndex) {
+            line.style.background = 'var(--vscode-button-background)';
+          } else {
+            line.style.background = 'var(--vscode-input-border)';
+          }
+        });
+      },
+
+      /**
+       * 前进到下一步
+       */
+      nextStep() {
+        const currentIndex = this.steps.indexOf(this.currentStep);
+        if (currentIndex < this.steps.length - 1) {
+          this.updateProgress(this.steps[currentIndex + 1]);
+        }
+      },
+
+      /**
+       * 重置进度条
+       */
+      reset() {
+        this.updateProgress('spec');
+      },
+
+      /**
+       * 完成所有步骤
+       */
+      complete() {
+        this.updateProgress('done');
+        // 将最后一步也标记为完成
+        const lastStep = document.querySelector('.progress-step[data-step="done"]');
+        if (lastStep) {
+          lastStep.classList.remove('active');
+          lastStep.classList.add('completed');
+        }
+      }
+    };
+
+    // 初始化进度条
+    ProgressBar.init();
+
+    // 监听来自扩展的消息以更新进度
+    window.addEventListener('message', (event) => {
+      const message = event.data;
+      if (message.type === 'updateProgress') {
+        ProgressBar.updateProgress(message.step);
+      } else if (message.type === 'resetProgress') {
+        ProgressBar.reset();
+      } else if (message.type === 'completeProgress') {
+        ProgressBar.complete();
+      } else if (message.type === 'showProgress') {
+        ProgressBar.show();
+      } else if (message.type === 'hideProgress') {
+        ProgressBar.hide();
+      }
+    });
+  `;
+}

src/views/thinkingProcess.ts

@@ -0,0 +1,178 @@
+/**
+ * 思考过程组件
+ *
+ * 功能说明:
+ * - 显示 AI 的思考过程
+ * - 支持展开/折叠功能
+ * - 提供打字机效果的流式显示
+ */
+
+/**
+ * 获取思考过程组件的 HTML 内容
+ * @param thinking - 思考内容
+ * @param isExpanded - 是否默认展开
+ */
+export function getThinkingProcessContent(
+  thinking: string = "",
+  isExpanded: boolean = false
+): string {
+  return `
+    <div class="thinking-process-container ${isExpanded ? "expanded" : ""}">
+      <div class="thinking-header">
+        <div class="thinking-icon-wrapper">
+          <svg class="thinking-icon" width="16" height="16" viewBox="0 0 16 16" fill="none">
+            <path d="M6 4l4 4-4 4" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"/>
+          </svg>
+        </div>
+        <span class="thinking-title">思考过程</span>
+      </div>
+      <div class="thinking-content">
+        <div class="thinking-text">${thinking || "正在思考中..."}</div>
+      </div>
+    </div>
+  `;
+}
+
+/**
+ * 获取思考过程组件的样式
+ */
+export function getThinkingProcessStyles(): string {
+  return `
+    .thinking-process-container {
+      margin: 12px 0;
+      border-radius: 6px;
+      background: var(--vscode-editor-background);
+      overflow: hidden;
+      transition: all 0.3s ease;
+    }
+
+    .thinking-header {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 5px 5px;
+      cursor: pointer;
+      user-select: none;
+      background: var(--vscode-input-background);
+      transition: background 0.2s ease;
+      width: 85px;
+      border-radius: 20px;
+      position: relative;
+      overflow: hidden;
+    }
+
+    .thinking-header::before {
+      content: '';
+      position: absolute;
+      top: 0;
+      left: -100%;
+      width: 100%;
+      height: 100%;
+      background: linear-gradient(
+        90deg,
+        transparent,
+        rgba(255, 255, 255, 0.1),
+        transparent
+      );
+      animation: none;
+    }
+
+    .thinking-process-container.typing .thinking-header::before {
+      animation: shine 2s ease-in-out infinite;
+    }
+
+    @keyframes shine {
+      0% {
+        left: -100%;
+      }
+      50%, 100% {
+        left: 100%;
+      }
+    }
+
+    .thinking-header:hover {
+      background: var(--vscode-list-hoverBackground);
+    }
+
+    .thinking-icon-wrapper {
+      flex-shrink: 0;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      transition: transform 0.3s ease;
+    }
+
+    .thinking-process-container.expanded .thinking-icon-wrapper {
+      transform: rotate(90deg);
+    }
+
+    .thinking-icon {
+      color: var(--vscode-descriptionForeground);
+    }
+
+    .thinking-title {
+      flex: 1;
+      font-size: 13px;
+      font-weight: 500;
+      color: var(--vscode-foreground);
+    }
+
+    .thinking-content {
+      max-height: 0;
+      overflow: hidden;
+      transition: max-height 0.3s ease, padding 0.3s ease;
+      padding: 0 12px;
+    }
+
+    .thinking-process-container.expanded .thinking-content {
+      max-height: 500px;
+      padding: 12px;
+      overflow-y: auto;
+    }
+
+    .thinking-text {
+      font-size: 12px;
+      line-height: 1.6;
+      color: var(--vscode-descriptionForeground);
+      white-space: pre-wrap;
+      word-wrap: break-word;
+      padding-left: 12px;
+      border-left: 2px solid var(--vscode-textBlockQuote-border);
+      position: relative;
+    }
+
+    /* 打字机效果 */
+    .thinking-text.typing::after {
+      content: '▋';
+      animation: blink 1s step-end infinite;
+      margin-left: 2px;
+    }
+
+    @keyframes blink {
+      0%, 50% {
+        opacity: 1;
+      }
+      51%, 100% {
+        opacity: 0;
+      }
+    }
+
+    /* 滚动条样式 */
+    .thinking-content::-webkit-scrollbar {
+      width: 6px;
+    }
+
+    .thinking-content::-webkit-scrollbar-track {
+      background: transparent;
+    }
+
+    .thinking-content::-webkit-scrollbar-thumb {
+      background: var(--vscode-scrollbarSlider-background);
+      border-radius: 3px;
+    }
+
+    .thinking-content::-webkit-scrollbar-thumb:hover {
+      background: var(--vscode-scrollbarSlider-hoverBackground);
+    }
+  `;
+}

src/views/userInfoComponent.ts

@@ -0,0 +1,287 @@
+/**
+ * 用户信息组件
+ * 包含用户头像、昵称、会员等级等信息
+ */
+
+/**
+ * 获取用户信息组件的 HTML 内容
+ * 只包含用户详情下拉面板,不包含触发按钮
+ */
+export function getUserInfoComponentContent(): string {
+  return `
+    <div class="user-info-wrapper">
+      <!-- 用户详情下拉面板 -->
+      <div class="user-detail-dropdown" id="userDetailDropdown">
+        <div class="user-detail-content">
+          <div class="user-detail-header">
+            <div class="user-avatar-small">
+              <svg viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">
+                <path d="M12 12c2.21 0 4-1.79 4-4s-1.79-4-4-4-4 1.79-4 4 1.79 4 4 4zm0 2c-2.67 0-8 1.34-8 4v2h16v-2c0-2.66-5.33-4-8-4z" fill="currentColor"/>
+              </svg>
+            </div>
+            <div class="user-name-tier">
+              <div class="user-detail-name" id="userDetailName">加载中...</div>
+              <img class="tier-icon-inline" id="tierIconInline" style="display: none;" />
+            </div>
+          </div>
+
+          <div class="user-detail-body">
+            <div class="user-detail-item">
+              <span class="detail-label">剩余 Credits</span>
+              <span class="detail-value" id="creditsDetail">-</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  `;
+}
+
+/**
+ * 获取用户信息组件的 CSS 样式
+ */
+export function getUserInfoComponentStyles(): string {
+  return `
+    .user-info-wrapper {
+      position: relative;
+    }
+
+    /* 用户详情下拉面板 */
+    .user-detail-dropdown {
+      display: none;
+      position: absolute;
+      top: calc(100% + 8px);
+      right: 0;
+      z-index: 10000;
+      min-width: 250px;
+      max-width: 320px;
+    }
+
+    .user-detail-dropdown.active {
+      display: block;
+      animation: dropdownSlideIn 0.2s ease-out;
+    }
+
+    @keyframes dropdownSlideIn {
+      from {
+        opacity: 0;
+        transform: translateY(-10px);
+      }
+      to {
+        opacity: 1;
+        transform: translateY(0);
+      }
+    }
+
+    .user-detail-content {
+      background: var(--vscode-sideBar-background);
+      border: 1px solid var(--vscode-widget-border);
+      border-radius: 8px;
+      box-shadow: 0 8px 24px rgba(0, 0, 0, 0.4);
+      overflow: hidden;
+    }
+
+    .user-detail-header {
+      padding: 16px;
+      display: flex;
+      align-items: center;
+      gap: 12px;
+      background: linear-gradient(135deg, rgba(0, 122, 204, 0.1) 0%, rgba(88, 166, 255, 0.05) 100%);
+      border-bottom: 1px solid var(--vscode-widget-border);
+    }
+
+    .user-avatar-small {
+      width: 26px;
+      height: 26px;
+      flex-shrink: 0;
+      background: linear-gradient(135deg, #007acc 0%, #58a6ff 100%);
+      border-radius: 50%;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      box-shadow: 0 2px 8px rgba(0, 122, 204, 0.3);
+    }
+
+    .user-avatar-small svg {
+      width: 18px;
+      height: 18px;
+      color: #ffffff;
+    }
+
+    .user-name-tier {
+      flex: 1;
+      display: flex;
+      align-items: center;
+      gap: 8px;
+    }
+
+    .user-detail-name {
+      font-size: 14px;
+      font-weight: 600;
+      color: var(--vscode-foreground);
+    }
+
+    .tier-icon-inline {
+      height: 26px;
+      object-fit: contain;
+    }
+
+    .user-detail-body {
+      padding: 12px;
+      background: var(--vscode-sideBar-background);
+    }
+
+    .user-detail-item {
+      display: flex;
+      justify-content: space-between;
+      align-items: center;
+      padding: 10px 12px;
+      margin-bottom: 6px;
+      background: var(--vscode-editor-background);
+      border-radius: 6px;
+      border: 1px solid var(--vscode-widget-border);
+      transition: all 0.2s ease;
+    }
+
+    .user-detail-item:hover {
+      background: var(--vscode-list-hoverBackground);
+      border-color: rgba(0, 122, 204, 0.3);
+    }
+
+    .user-detail-item:last-child {
+      margin-bottom: 0;
+    }
+
+    .detail-label {
+      font-size: 12px;
+      font-weight: 500;
+      color: var(--vscode-descriptionForeground);
+      opacity: 0.8;
+    }
+
+    .detail-value {
+      font-size: 12px;
+      font-weight: 500;
+      color: var(--vscode-foreground);
+      display: flex;
+      align-items: center;
+      gap: 6px;
+    }
+
+    .tier-icon-large {
+      height: 20px;
+      object-fit: contain;
+    }
+
+    .tier-icon {
+      width: 110px;
+      height: 35px;
+      flex-shrink: 0;
+      object-fit: contain;
+      border-radius: 4px;
+    }
+  `;
+}
+
+/**
+ * 获取用户信息组件的 JavaScript 脚本
+ */
+export function getUserInfoComponentScript(): string {
+  return `
+    // 用户信息数据
+    let currentUserInfo = null;
+
+    // 切换用户详情下拉面板
+    function openUserDetailModal() {
+      const dropdown = document.getElementById('userDetailDropdown');
+      const userButton = document.getElementById('userAvatarIconButton');
+
+      if (dropdown) {
+        const isActive = dropdown.classList.contains('active');
+        if (isActive) {
+          dropdown.classList.remove('active');
+          if (userButton) {
+            userButton.classList.remove('active');
+          }
+        } else {
+          dropdown.classList.add('active');
+          if (userButton) {
+            userButton.classList.add('active');
+          }
+          // 更新下拉面板中的用户信息
+          updateUserDetailModal();
+        }
+      }
+    }
+
+    // 关闭用户详情下拉面板
+    function closeUserDetailModal() {
+      const dropdown = document.getElementById('userDetailDropdown');
+      const userButton = document.getElementById('userAvatarIconButton');
+
+      if (dropdown) {
+        dropdown.classList.remove('active');
+      }
+      if (userButton) {
+        userButton.classList.remove('active');
+      }
+    }
+
+    // 更新用户详情下拉面板内容
+    function updateUserDetailModal() {
+      if (!currentUserInfo) {
+        return;
+      }
+
+      // 更新用户名
+      const userDetailName = document.getElementById('userDetailName');
+      if (userDetailName) {
+        userDetailName.textContent = currentUserInfo.nickname || '未知用户';
+      }
+
+      // 更新会员等级图标(显示在用户名旁边)
+      const tierIconInline = document.getElementById('tierIconInline');
+      if (tierIconInline && currentUserInfo.tierIconUrl) {
+        tierIconInline.src = currentUserInfo.tierIconUrl;
+        tierIconInline.style.display = 'block';
+      } else if (tierIconInline) {
+        tierIconInline.style.display = 'none';
+      }
+
+      // 更新剩余 Credits
+      const creditsDetail = document.getElementById('creditsDetail');
+      if (creditsDetail) {
+        creditsDetail.textContent = currentUserInfo.credits !== undefined ? currentUserInfo.credits.toString() : '-';
+      }
+    }
+
+    // 更新用户信息显示
+    function updateUserInfoDisplay(userInfo) {
+      currentUserInfo = userInfo;
+    }
+
+    // 绑定下拉面板事件
+    document.addEventListener('DOMContentLoaded', () => {
+      // 点击页面其他地方关闭下拉面板
+      document.addEventListener('click', (e) => {
+        const dropdown = document.getElementById('userDetailDropdown');
+        const userButton = document.getElementById('userAvatarIconButton');
+
+        if (dropdown && dropdown.classList.contains('active')) {
+          // 如果点击的不是用户按钮和下拉面板内容，则关闭
+          if (!userButton?.contains(e.target) && !dropdown.contains(e.target)) {
+            closeUserDetailModal();
+          }
+        }
+      });
+
+      // 阻止下拉面板内容点击事件冒泡
+      const dropdownContent = document.querySelector('.user-detail-content');
+      if (dropdownContent) {
+        dropdownContent.addEventListener('click', (e) => {
+          e.stopPropagation();
+        });
+      }
+    });
+  `;
+}

src/views/waveformPreviewContent.ts

@@ -5,65 +5,79 @@ export function getWaveformPreviewContent(): string {
   return `
       /* 波形预览组件样式 */
       .waveform-preview {
-        margin-top: 12px;
+        margin: 16px 0;
         border: 1px solid var(--vscode-panel-border);
-        border-radius: 8px;
+        border-radius: 12px;
         overflow: hidden;
         background: var(--vscode-editor-background);
+        box-shadow: 0 2px 8px rgba(0, 0, 0, 0.1);
+        transition: box-shadow 0.3s ease, transform 0.2s ease;
+      }
+      .waveform-preview:hover {
+        box-shadow: 0 4px 16px rgba(0, 0, 0, 0.15);
+        transform: translateY(-2px);
       }
       .waveform-preview-header {
         display: flex;
         align-items: center;
         justify-content: space-between;
-        padding: 10px 12px;
+        padding: 14px 16px;
-        background: var(--vscode-input-background);
+        background: linear-gradient(135deg, var(--vscode-input-background) 0%, var(--vscode-editor-background) 100%);
         border-bottom: 1px solid var(--vscode-panel-border);
+        backdrop-filter: blur(10px);
       }
       .waveform-preview-title {
         display: flex;
         align-items: center;
-        gap: 8px;
+        gap: 10px;
-        font-size: 13px;
+        font-size: 14px;
-        font-weight: 500;
+        font-weight: 600;
         color: var(--vscode-foreground);
+        letter-spacing: 0.3px;
       }
       .waveform-preview-title svg {
-        width: 16px;
+        width: 18px;
-        height: 16px;
+        height: 18px;
         color: var(--vscode-button-background);
+        filter: drop-shadow(0 1px 2px rgba(0, 0, 0, 0.2));
       }
       .waveform-expand-btn {
-        padding: 4px 12px;
+        padding: 6px 14px;
         background: var(--vscode-button-background);
         color: var(--vscode-button-foreground);
         border: none;
-        border-radius: 4px;
+        border-radius: 6px;
         cursor: pointer;
         font-size: 12px;
+        font-weight: 500;
         display: flex;
         align-items: center;
-        gap: 4px;
+        gap: 6px;
-        transition: opacity 0.2s ease;
+        transition: all 0.2s ease;
+        box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
       }
       .waveform-expand-btn:hover {
-        opacity: 0.9;
+        background: var(--vscode-button-hoverBackground);
+        transform: translateY(-1px);
+        box-shadow: 0 4px 8px rgba(0, 0, 0, 0.15);
+      }
+      .waveform-expand-btn:active {
+        transform: translateY(0);
+        box-shadow: 0 1px 2px rgba(0, 0, 0, 0.1);
       }
       .waveform-expand-btn svg {
         width: 14px;
         height: 14px;
       }
       .waveform-preview-content {
-        padding: 0;
+        padding: 12px;
-        min-height: 200px;
-        max-height: 300px;
         overflow: hidden;
         position: relative;
         background: var(--vscode-editor-background);
       }
       .waveform-preview-canvas {
         width: 100%;
-        height: 100%;
+        height: auto;
-        min-height: 200px;
       }
       .waveform-preview-placeholder {
         display: flex;
@@ -88,7 +102,8 @@ export function getWaveformPreviewContent(): string {
       }
       .waveform-mini-viewer {
         width: 100%;
-        height: 200px;
+        height: auto;
+        min-height: 120px;
         background: var(--vscode-editor-background);
         position: relative;
         overflow: hidden;
@@ -203,8 +218,16 @@ export function getWaveformPreviewScript(): string {
      * 渲染波形预览信息
      */
     function renderWaveformInfo(containerId, vcdInfo) {
+      console.log('[renderWaveformInfo] 开始渲染波形, containerId:', containerId);
+      console.log('[renderWaveformInfo] vcdInfo:', vcdInfo);
+
       const container = document.getElementById(containerId);
-      if (!container) return;
+      if (!container) {
+        console.error('[renderWaveformInfo] 找不到容器:', containerId);
+        return;
+      }
+
+      console.log('[renderWaveformInfo] 找到容器，信号数量:', vcdInfo.signals?.length || 0);
 
       // 清空容器
       container.innerHTML = '';
@@ -214,6 +237,7 @@ export function getWaveformPreviewScript(): string {
       waveformSvg.innerHTML = drawRealWaveform(vcdInfo.signals || []);
 
       container.appendChild(waveformSvg);
+      console.log('[renderWaveformInfo] 波形渲染完成');
     }
 
     /**
@@ -263,61 +287,63 @@ export function getWaveformPreviewScript(): string {
         const timeRange = maxTime - minTime || 1;
 
         // 绘制波形
-        let pathData = '';
+        if (signal.width === 1) {
-        let lastX = leftMargin;
+          // 单比特信号 - 绘制数字波形
-        let lastValue = signal.values[0].value;
+          let pathData = '';
+          const yHigh = y;
+          const yLow = y + signalHeight;
 
-        signal.values.forEach((point, i) => {
+          signal.values.forEach((point, i) => {
-          const x = leftMargin + ((point.time - minTime) / timeRange) * waveformWidth;
+            const x = leftMargin + ((point.time - minTime) / timeRange) * waveformWidth;
-          const value = point.value;
+            const currentY = (point.value === '1') ? yHigh : yLow;
-
-          if (signal.width === 1) {
-            // 单比特信号 - 绘制数字波形
-            const yHigh = y;
-            const yLow = y + signalHeight;
-            const currentY = (value === '1') ? yHigh : yLow;
 
             if (i === 0) {
               pathData = \`M \${x} \${currentY}\`;
             } else {
-              // 绘制垂直跳变
+              const prevValue = signal.values[i - 1].value;
-              const prevY = (lastValue === '1') ? yHigh : yLow;
+              const prevY = (prevValue === '1') ? yHigh : yLow;
               if (prevY !== currentY) {
                 pathData += \` L \${x} \${prevY} L \${x} \${currentY}\`;
               } else {
                 pathData += \` L \${x} \${currentY}\`;
               }
             }
+          });
 
-            lastValue = value;
+          // 延伸到右边界
-            lastX = x;
+          const lastValue = signal.values[signal.values.length - 1].value;
-          } else {
+          const lastY = (lastValue === '1') ? yHigh : yLow;
-            // 多比特信号 - 绘制总线波形（梯形）
-            const yTop = y + 5;
-            const yBottom = y + signalHeight - 5;
-            const transitionWidth = 5;
-
-            if (i === 0) {
-              pathData = \`M \${x} \${yTop + (yBottom - yTop) / 2}\`;
-            } else {
-              // 绘制梯形过渡
-              pathData += \` L \${x - transitionWidth} \${yTop} L \${x} \${yTop + (yBottom - yTop) / 2}\`;
-            }
-
-            lastX = x;
-          }
-        });
-
-        // 延伸到右边界
-        if (signal.width === 1) {
-          const lastY = (lastValue === '1') ? y : (y + signalHeight);
           pathData += \` L \${leftMargin + waveformWidth} \${lastY}\`;
-        } else {
-          const yMid = y + signalHeight / 2;
-          pathData += \` L \${leftMargin + waveformWidth} \${yMid}\`;
-        }
 
-        svgContent += \`<path d="\${pathData}" stroke="\${color}" stroke-width="1.5" fill="none"/>\`;
+          svgContent += \`<path d="\${pathData}" stroke="\${color}" stroke-width="1.5" fill="none"/>\`;
+        } else {
+          // 多比特信号 - 绘制总线波形（上下双线）
+          const yTop = y + 5;
+          const yBottom = y + signalHeight - 5;
+          const transitionWidth = 4;
+
+          let topPath = \`M \${leftMargin} \${yTop}\`;
+          let bottomPath = \`M \${leftMargin} \${yBottom}\`;
+
+          signal.values.forEach((point, i) => {
+            const x = leftMargin + ((point.time - minTime) / timeRange) * waveformWidth;
+
+            // 上线和下线都延伸到变化点
+            topPath += \` L \${x} \${yTop}\`;
+            bottomPath += \` L \${x} \${yBottom}\`;
+
+            // 绘制梯形过渡
+            topPath += \` L \${x + transitionWidth} \${yBottom} L \${x + transitionWidth} \${yTop}\`;
+            bottomPath += \` L \${x + transitionWidth} \${yTop} L \${x + transitionWidth} \${yBottom}\`;
+          });
+
+          // 延伸到右边界
+          topPath += \` L \${leftMargin + waveformWidth} \${yTop}\`;
+          bottomPath += \` L \${leftMargin + waveformWidth} \${yBottom}\`;
+
+          svgContent += \`<path d="\${topPath}" stroke="\${color}" stroke-width="1.5" fill="none"/>\`;
+          svgContent += \`<path d="\${bottomPath}" stroke="\${color}" stroke-width="1.5" fill="none"/>\`;
+        }
       });
 
       // 绘制时间轴
@@ -330,7 +356,7 @@ export function getWaveformPreviewScript(): string {
     }
 
     /**
-     * 打开完整波形查看器
+     * 打开完整波形查看器（在新列中）
      */
     function openFullWaveform(vcdFilePath) {
       vscode.postMessage({

tools/waveform_trace/build.bat

@@ -0,0 +1,42 @@
+@echo off
+REM waveform_trace 打包脚本 (Windows)
+REM 用法: build.bat
+
+echo ========================================
+echo   waveform_trace 打包脚本
+echo ========================================
+
+cd /d "%~dp0src"
+
+echo.
+echo [1/3] 安装依赖...
+pip install -r requirements.txt
+if %errorlevel% neq 0 (
+    echo 错误: 依赖安装失败
+    exit /b 1
+)
+
+echo.
+echo [2/3] 清理旧文件...
+if exist build rmdir /s /q build
+if exist dist rmdir /s /q dist
+if exist waveform_trace.spec del waveform_trace.spec
+
+echo.
+echo [3/3] PyInstaller 打包...
+pyinstaller --onefile --name waveform_trace --collect-all pyverilog waveform_trace_cli.py
+if %errorlevel% neq 0 (
+    echo 错误: 打包失败
+    exit /b 1
+)
+
+echo.
+echo [4/4] 复制到 bin 目录...
+if not exist "..\bin" mkdir "..\bin"
+copy /y "dist\waveform_trace.exe" "..\bin\"
+
+echo.
+echo ========================================
+echo   打包完成!
+echo   输出: tools/waveform_trace/bin/waveform_trace.exe
+echo ========================================

tools/waveform_trace/build.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+# waveform_trace 打包脚本 (Linux/macOS)
+# 用法: ./build.sh
+
+set -e
+
+echo "========================================"
+echo "  waveform_trace 打包脚本"
+echo "========================================"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+cd "$SCRIPT_DIR/src"
+
+echo ""
+echo "[1/4] 安装依赖..."
+pip install -r requirements.txt
+
+echo ""
+echo "[2/4] 清理旧文件..."
+rm -rf build dist *.spec
+
+echo ""
+echo "[3/4] PyInstaller 打包..."
+pyinstaller --onefile --name waveform_trace --collect-all pyverilog waveform_trace_cli.py
+
+echo ""
+echo "[4/4] 复制到 bin 目录..."
+mkdir -p ../bin
+cp dist/waveform_trace ../bin/
+
+echo ""
+echo "========================================"
+echo "  打包完成!"
+echo "  输出: tools/waveform_trace/bin/waveform_trace"
+echo "========================================"

tools/waveform_trace/src/README.md

@@ -0,0 +1,115 @@
+# AST 波形调试核心代码
+
+## 文件说明
+
+| 文件 | 作用 | 核心函数 | TS重写需要 |
+|------|------|----------|------------|
+| `ast_node.py` | AST节点定义，遍历建图 | `toplogic_tree_traverse()` | ✅ 已完成 |
+| `graph_builder.py` | 入口函数，调用解析器 | `generate_top_logic_graph()` | ✅ 已完成 |
+| `debug_graph_analyzer.py` | BFS回溯控制信号 | `get_k_control_signals()` | ⚠️ 需重写 |
+| `vcd_waveform_analyzer.py` | VCD波形文件解析 | `parse_mismatch()`, `get_tabular()` | ⚠️ 需重写 |
+| `waveform_trace_tool.py` | 完整追踪工具封装 | `waveform_trace_tool()` | ⚠️ 需重写 |
+
+---
+
+## 调用流程
+
+```
+Verilog代码文件
+       │
+       ▼
+┌─────────────────────────────────────┐
+│ graph_builder.py                    │
+│ generate_top_logic_graph(filelist)  │
+│       │                             │
+│       ▼                             │
+│ PyVerilog.parse() → AST             │
+│       │                             │
+│       ▼                             │
+│ ast.toplogic_tree_traverse()        │
+│       │                             │
+│       ▼                             │
+│ NetworkX 有向图（信号依赖图）       │
+└─────────────────────────────────────┘
+       │
+       ▼
+┌─────────────────────────────────────┐
+│ debug_graph_analyzer.py             │
+│ DebugGraph.get_k_control_signals()  │
+│       │                             │
+│       ▼                             │
+│ BFS回溯K层，找到控制信号链          │
+└─────────────────────────────────────┘
+       │
+       ▼
+┌─────────────────────────────────────┐
+│ vcd_waveform_analyzer.py            │
+│ parse_mismatch() + get_tabular()    │
+│       │                             │
+│       ▼                             │
+│ 提取相关信号的波形表                │
+└─────────────────────────────────────┘
+```
+
+---
+
+## 核心代码位置
+
+### 1. AST遍历建图 (ast_node.py:32-137)
+
+```python
+def toplogic_tree_traverse(self, network_G, rvalue=False, lvalue=False, offset=0):
+    """
+    递归遍历AST，提取信号依赖关系，填充到NetworkX图中
+
+    关键逻辑：
+    1. 识别 Rvalue（右值）和 Lvalue（左值）
+    2. 递归收集子节点的信号
+    3. 建立边：右值信号 → 左值信号（控制关系）
+    """
+```
+
+### 2. 图构建入口 (graph_builder.py:89-99)
+
+```python
+def generate_top_logic_graph(filelist: list[str]):
+    # 1. PyVerilog解析Verilog代码
+    ast, directives = parse(filelist, preprocess_include=[], preprocess_define=[])
+    # 2. 遍历AST，构建信号依赖图
+    return create_graph_from_ast(ast, display=False, display_signal_only=False)
+```
+
+### 3. BFS回溯 (debug_graph_analyzer.py:20-66)
+
+```python
+def get_k_control_signals(self, target_signals: list[str], k: int, signal_only: bool = False):
+    """
+    从出错信号出发，BFS回溯K层，找到所有控制信号
+
+    输入：target_signals = ['out']  # 出错的信号
+    输出：control_signals = {'out': (10,10), 'state': (5,8), 'clk': (1,1)}
+          signal_level_tracer = [['clk->state', 'reset->state'], ['state->out']]
+    """
+```
+
+---
+
+## 依赖库
+
+```
+pyverilog    # Verilog解析，生成AST
+networkx     # 图数据结构
+pandas       # 波形数据处理（可选）
+```
+
+---
+
+## 如果要用JavaScript重写
+
+需要重写的核心逻辑：
+
+1. **Verilog解析器** → 用 ANTLR4 + Verilog.g4 或 tree-sitter-verilog
+2. **AST遍历建图** → 约100行，参考 ast_node.py:32-137
+3. **BFS回溯** → 约70行，参考 debug_graph_analyzer.py
+
+总计约 **200行核心逻辑**（不含解析器）

tools/waveform_trace/src/TS_REWRITE_SPEC.md

@@ -0,0 +1,455 @@
+# AST波形调试工具 - TypeScript重写规范
+
+## 一、项目背景
+
+将Python实现的Verilog AST波形调试工具重写为TypeScript，用于VSCode插件。
+
+**已完成部分**：
+- ✅ Verilog AST解析（生成JSON格式的信号依赖图）
+- ✅ 图结构定义
+
+**待重写部分**：
+- ⚠️ BFS信号回溯
+- ⚠️ VCD波形解析
+- ⚠️ 仿真输出解析
+- ⚠️ 工具整合封装
+
+---
+
+## 二、数据结构定义
+
+### 2.1 AST图结构（已完成）
+
+```typescript
+interface ASTNode {
+  id: string;
+  attributes: {
+    lines: [number, number];  // [起始行, 结束行]
+    type: string;             // Input/Output/Reg/Wire/Always/Assign等
+  };
+}
+
+interface ASTEdge {
+  from: string;   // 控制信号
+  to: string;     // 被控制信号
+  attributes: {
+    lines: [number, number];
+    type: string;  // Always/Assign/IfStatement等
+  };
+}
+
+interface ASTGraph {
+  metadata: {
+    moduleName: string;
+    nodeCount: number;
+    edgeCount: number;
+    generatedAt: string;
+  };
+  nodes: ASTNode[];
+  edges: ASTEdge[];
+}
+```
+
+### 2.2 追踪结果结构
+
+```typescript
+interface TraceResult {
+  controlSignals: Map<string, [number, number]>;  // 信号名 -> 代码行号
+  signalLevelTracer: string[][];                  // 每层的控制关系链
+}
+```
+
+### 2.3 波形数据结构
+
+```typescript
+interface WaveformData {
+  time: number;           // 时间点(ns)
+  signals: {
+    [signalName: string]: string;  // 信号名 -> 值(十六进制)
+  };
+}
+
+interface MismatchInfo {
+  signals: string[];      // 出错的信号列表
+  firstMismatchTime: number;  // 第一次出错的时间
+}
+```
+
+---
+
+## 三、需要重写的模块
+
+### 3.1 BFS信号回溯模块
+
+**源文件**: `debug_graph_analyzer.py`
+**代码行数**: ~70行
+**第三方依赖**: 无
+
+#### 功能描述
+从出错信号出发，BFS反向遍历图，找到所有控制该信号的上游信号。
+
+#### 输入输出
+```typescript
+// 输入
+graph: ASTGraph           // AST图（JSON格式）
+targetSignals: string[]   // 出错的信号列表，如 ['count', 'overflow']
+k: number                 // 回溯层数
+signalOnly: boolean       // 是否只返回信号节点（过滤Always/Assign等）
+
+// 输出
+TraceResult {
+  controlSignals: Map<string, [number, number]>,
+  signalLevelTracer: string[][]
+}
+```
+
+#### 核心算法（伪代码）
+```
+1. 构建前驱映射（反向边）
+   for each edge in graph.edges:
+     predecessorMap[edge.to].push(edge.from)
+
+2. 初始化BFS队列
+   for each signal in targetSignals:
+     queue.push([signal, signal])
+     controlSignals.set(signal, node.lines)
+
+3. BFS遍历K层
+   for level = 0 to k:
+     while queue not empty:
+       [curSignal, controlledSignal] = queue.pop()
+       记录关系: curSignal -> controlledSignal
+
+       for each predecessor of curSignal:
+         if not visited and not filtered:
+           queue.push([predecessor, curSignal])
+
+     记录本层关系到 signalLevelTracer
+
+4. 返回结果
+```
+
+#### 过滤规则
+```typescript
+// 需要过滤的节点类型
+const FILTERED_TYPES = ['Parameter', 'Localparam'];
+
+// signalOnly=true时，还需要过滤以下前缀
+const FILTERED_PREFIXES = ['Always', 'Assign', 'Module', 'IntConst'];
+```
+
+---
+
+### 3.2 仿真输出解析模块
+
+**源文件**: `vcd_waveform_analyzer.py` 中的 `parse_mismatch()`
+**代码行数**: ~20行
+**第三方依赖**: 无
+
+#### 功能描述
+解析仿真工具的输出文本，提取出错信号名和出错时间。
+
+#### 输入输出
+```typescript
+// 输入
+testOutput: string  // 仿真工具的输出文本
+
+// 输出
+MismatchInfo {
+  signals: string[],        // 出错信号列表
+  firstMismatchTime: number // 第一次出错时间(ns)
+}
+```
+
+#### 解析规则
+```typescript
+// 需要匹配的格式
+// "First mismatch occurred at time 100. Output 'count' ..."
+
+const pattern = /First mismatch occurred at time (\d+).*Output '(\w+)'/g;
+
+// 提取所有匹配
+// 返回信号列表和最小时间戳
+```
+
+#### 示例
+```
+输入:
+"First mismatch occurred at time 100. Output 'count' expected 0001, got 0000
+First mismatch occurred at time 150. Output 'overflow' expected 1, got 0"
+
+输出:
+{
+  signals: ['count', 'overflow'],
+  firstMismatchTime: 100
+}
+```
+
+---
+
+### 3.3 VCD波形解析模块
+
+**源文件**: `vcd_waveform_analyzer.py` 中的 `get_tabular()` 和 `tabular_via_dataframe()`
+**代码行数**: ~150行
+**第三方依赖**: Python版用了 `vcdvcd`, `pandas`, `numpy`
+
+#### 功能描述
+读取VCD（Value Change Dump）波形文件，提取指定信号的波形值，生成表格。
+
+#### VCD文件格式简介
+```vcd
+$timescale 1ns $end
+$scope module tb $end
+$var wire 1 ! clk $end
+$var wire 8 " count [7:0] $end
+$upscope $end
+$enddefinitions $end
+#0
+b0 "
+1!
+#5
+0!
+#10
+1!
+b00000001 "
+...
+```
+
+#### 输入输出
+```typescript
+// 输入
+vcdPath: string           // VCD文件路径
+signalsToTrace: string[]  // 需要提取的信号列表
+offset: number            // 时间偏移（从哪个时间点开始）
+windowSize: number        // 窗口大小（提取多少个时间点）
+
+// 输出
+string  // 格式化的波形表格字符串
+```
+
+#### 输出格式示例
+```
+### First mismatched signals time(ns) Trace ###
+time(ns)  clk  reset  count_ref  count_dut
+0         1    1      00         00
+5         0    1      00         00
+10        1    0      00         00
+15        0    0      00         00
+20        1    0      01         00  <- mismatch
+### First mismatched signals time(ns) End ###
+```
+
+#### TS实现建议
+1. **方案A**: 找现有的JS VCD解析库
+   - 搜索: `npm vcd parser`, `vcd-stream`, `wavedrom`
+
+2. **方案B**: 自己实现简单的VCD解析器
+   - VCD格式相对简单，核心是解析变量定义和时间变化
+   - 约100-150行代码
+
+#### VCD解析核心逻辑
+```typescript
+class VCDParser {
+  signals: Map<string, Signal>;  // 信号定义
+  timeValues: Map<number, Map<string, string>>;  // 时间 -> 信号值
+
+  parse(vcdContent: string): void {
+    // 1. 解析头部（$var定义）
+    // 2. 解析数据部分（#时间 和 值变化）
+  }
+
+  getSignalValues(signalName: string, startTime: number, endTime: number): WaveformData[] {
+    // 提取指定信号在时间范围内的值
+  }
+}
+```
+
+---
+
+### 3.4 工具整合封装模块
+
+**源文件**: `waveform_trace_tool.py`
+**代码行数**: ~150行
+**第三方依赖**: 依赖上面所有模块
+
+#### 功能描述
+整合所有模块，提供统一的调试接口。
+
+#### 输入输出
+```typescript
+// 输入
+verilogFilePath: string      // Verilog文件路径
+vcdFilePath: string          // VCD波形文件路径
+simulationOutput: string     // 仿真输出文本
+traceLevel: number           // 回溯层数
+
+// 输出
+string  // 完整的调试报告
+```
+
+#### 调试报告格式
+```
+[Signal Traces] Backtrace control signal relations.
+clk->count
+reset->count
+-count->state
+--state->out (*last output port level)
+
+[Signal Waveform]:
+<signal>_ref 是期望值（golden）
+<signal>_dut 是实际输出
+[Traced Signals]: out, state, count, clk, reset
+
+[Table Waveform in hexadecimal format]
+time(ns)  clk  reset  count_ref  count_dut
+...
+
+[Verilog of DUT]:
+```verilog
+module counter(...);
+...
+endmodule
+```
+
+[Hint] ...
+```
+
+---
+
+## 四、调用流程图
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│                     waveform_trace_tool()                       │
+├─────────────────────────────────────────────────────────────────┤
+│                                                                 │
+│  1. 检查文件是否存在                                            │
+│     ├── verilogFilePath                                         │
+│     └── vcdFilePath                                             │
+│                                                                 │
+│  2. 加载AST图（已有JSON）                                       │
+│     └── graph = loadASTGraph(verilogFilePath)                   │
+│                                                                 │
+│  3. 解析仿真输出，获取出错信号                                  │
+│     └── mismatchInfo = parseMismatch(simulationOutput)          │
+│         ├── signals: ['count', 'overflow']                      │
+│         └── firstMismatchTime: 100                              │
+│                                                                 │
+│  4. BFS回溯，找到控制信号链                                     │
+│     └── traceResult = getKControlSignals(graph, signals, k)     │
+│         ├── controlSignals: Map<信号名, 行号>                   │
+│         └── signalLevelTracer: [['clk->count'], ...]            │
+│                                                                 │
+│  5. 读取VCD波形，提取相关信号的值                               │
+│     └── waveformTable = getTabular(vcdPath, signals, offset)    │
+│                                                                 │
+│  6. 读取Verilog源码                                             │
+│     └── verilogCode = readFile(verilogFilePath)                 │
+│                                                                 │
+│  7. 组装调试报告                                                │
+│     └── return formatReport(traceResult, waveformTable, code)   │
+│                                                                 │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 五、参考实现
+
+### 5.1 Python源文件位置
+
+```
+ast_debug_core/
+├── ast_node.py              # AST节点定义（参考32-137行）
+├── graph_builder.py         # 图构建入口
+├── debug_graph_analyzer.py  # BFS回溯（完整文件，约70行）
+├── vcd_waveform_analyzer.py # VCD解析（参考89-285行）
+└── waveform_trace_tool.py   # 工具封装（完整文件，约180行）
+```
+
+### 5.2 关键函数对照表
+
+| Python函数 | 位置 | TS函数名建议 |
+|------------|------|--------------|
+| `get_k_control_signals()` | debug_graph_analyzer.py:20 | `getKControlSignals()` |
+| `parse_mismatch()` | vcd_waveform_analyzer.py:244 | `parseMismatch()` |
+| `get_tabular()` | vcd_waveform_analyzer.py:264 | `getTabular()` |
+| `tabular_via_dataframe()` | vcd_waveform_analyzer.py:95 | `generateWaveformTable()` |
+| `waveform_trace_tool()` | waveform_trace_tool.py:63 | `waveformTraceTool()` |
+
+---
+
+## 六、测试用例
+
+### 6.1 BFS回溯测试
+
+```typescript
+// 输入
+const graph: ASTGraph = /* 加载 counter_ast_graph.json */;
+const targetSignals = ['count'];
+const k = 2;
+
+// 期望输出
+const expected = {
+  controlSignals: new Map([
+    ['count', [6, 6]],
+    ['next_count', [10, 10]],
+    ['reset', [4, 4]],
+    ['clk', [3, 3]],
+    ['enable', [5, 5]]
+  ]),
+  signalLevelTracer: [
+    ['count->count'],
+    ['next_count->count', 'reset->count', 'clk->count'],
+    ['enable->next_count', 'count->next_count']
+  ]
+};
+```
+
+### 6.2 仿真输出解析测试
+
+```typescript
+// 输入
+const testOutput = `
+Mismatches: 2
+First mismatch occurred at time 100. Output 'count' expected 0001, got 0000
+First mismatch occurred at time 150. Output 'overflow' expected 1, got 0
+`;
+
+// 期望输出
+const expected = {
+  signals: ['count', 'overflow'],
+  firstMismatchTime: 100
+};
+```
+
+---
+
+## 七、注意事项
+
+1. **无第三方依赖要求**
+   - BFS回溯和仿真解析完全可以用原生TS实现
+   - VCD解析可以自己实现或找现有库
+
+2. **性能考虑**
+   - 图遍历使用Map而非Object，提高查找效率
+   - VCD文件可能很大，考虑流式解析
+
+3. **错误处理**
+   - 文件不存在时返回友好错误信息
+   - 信号不在图中时跳过而非报错
+
+4. **兼容性**
+   - 信号名可能包含方括号，如 `count[7:0]`
+   - 时间单位统一为ns
+
+---
+
+## 八、交付物
+
+1. `debugGraphAnalyzer.ts` - BFS回溯模块
+2. `simulationParser.ts` - 仿真输出解析模块
+3. `vcdParser.ts` - VCD波形解析模块
+4. `waveformTraceTool.ts` - 工具整合封装
+5. `types.ts` - 类型定义
+6. 单元测试文件

tools/waveform_trace/src/debug_graph_analyzer.py

@@ -0,0 +1,70 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Author : Chia-Tung (Mark) Ho, NVIDIA
+#
+
+import copy
+import re
+from collections import deque
+from graph_builder import generate_top_logic_graph
+
+# use class
+class DebugGraph:
+
+    def __init__(self, verilog_filelist: list[str]):
+        self.filelist = verilog_filelist
+        self.graph = generate_top_logic_graph(verilog_filelist)
+        # print(list(self.graph.nodes(data=True)))
+
+    def get_k_control_signals(self, target_signals: list[str], k:int, signal_only: bool=False) -> list[str]:
+
+        control_signals = {}
+        signal_level_tracer = []
+        # queue
+        q = deque()
+        tmp_q = deque()
+
+        for signal in target_signals:
+            # store (predecessors, controlled signal)
+            q.append((signal, signal))
+            control_signals[signal] = self.graph.nodes[signal]['lines']
+
+        # BFS
+        for l in range (k + 1):
+            # traverse l layers
+            tmp_q.clear()
+            level_signal_control_rels = []
+            while len(q) > 0:
+                cur_signal = q.popleft()
+                level_signal_control_rels.append(cur_signal[0] + "->" + cur_signal[1])
+                if cur_signal[0] not in control_signals:
+                    if self.graph.has_edge(cur_signal[0], cur_signal[1]):
+                        # must be the control signals through the edge
+                        control_signals[cur_signal[0]] = self.graph[cur_signal[0]][cur_signal[1]]['lines']
+                    else:
+                        print("[Error] Edge not found! - ", cur_signal)
+                # find the predecessors
+                controls = self.graph.predecessors(cur_signal[0])
+                for c in controls:
+                    if c in control_signals:
+                        continue
+                    # exclude the parameter
+                    if 'type' in self.graph.nodes[c] and self.graph.nodes[c]['type'] in ["Parameter", "Localparam"]:
+                        continue
+                    if signal_only and (re.match('^Always', c) or re.match('^Assign', c) or re.match('^Module', c) or re.match('^IntConst', c)):
+                        continue
+                    # store (predecessors, controlled signal)
+                    tmp_q.append((c, cur_signal[0]))
+            # swap the q
+            assert(len(q) == 0)
+            print(tmp_q)
+            q = copy.deepcopy(tmp_q)
+            # record the signal relations
+            signal_level_tracer.append(level_signal_control_rels)
+
+        return control_signals, signal_level_tracer
+
+if __name__ == '__main__':
+    debug_graph_tracer = DebugGraph(["/home/scratch.chiatungh_nvresearch/hardware-agent-marco/hardware_agent/examples/verilog_testcases/fsm_serialdata.v"])
+    print(debug_graph_tracer.get_k_control_signals(['out_byte', 'done'], k=3, signal_only=True))

tools/waveform_trace/src/graph_builder.py

@@ -0,0 +1,144 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+# Author : Chia-Tung (Mark) Ho, NVIDIA
+#
+
+from __future__ import print_function
+import sys
+import os
+from optparse import OptionParser
+
+# 优先使用本地修改过的 pyverilog（包含 toplogic_tree_traverse 方法）
+_local_path = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, _local_path)
+
+from pyverilog.vparser.parser import parse
+from io import StringIO
+import networkx as nx
+# importing matplotlib.pyplot
+import matplotlib.pyplot as plt
+import re
+
+# create graph from ast str
+# directed graph from networkX
+def create_graph_from_ast(ast, display=False, display_signal_only=False):
+    graph = nx.DiGraph()
+    ast.toplogic_tree_traverse(network_G=graph, rvalue=False, lvalue=False)
+    if not display and not display_signal_only:
+        return graph
+    # Print out nodes with attributes
+    nodes_to_display = []
+    edges_to_display = []
+    print("Nodes:")
+    for node, attrs in graph.nodes(data=True):
+        if display_signal_only and (not re.match("^Assign", node) and not re.match("^Always", node) and not re.match("^Module", node)):
+            nodes_to_display.append(node)
+        print(f"Node {node}: {attrs}")
+
+    # Print out edges with attributes
+    print("\nEdges:")
+    for src, dst, attrs in graph.edges(data=True):
+        if display_signal_only and src in nodes_to_display and dst in nodes_to_display:
+            edges_to_display.append((src, dst))
+        print(f"Edge {src} to {dst}: {attrs}")
+
+    # displaying graphs
+    plt.figure(figsize=(18, 16))  # Set the figure size
+    pos = nx.spring_layout(graph, k=1.0)
+    if display_signal_only:
+        subgraph = graph.subgraph(nodes_to_display)
+        # subgraph.add_edges_from(edges_to_display)
+    else:
+        subgraph = graph
+
+    nx.draw_networkx(subgraph, pos, with_labels=True)  # Draw the graph without labels
+
+    # Add node labels
+    # node_labels = nx.get_node_attributes(graph, 'label')
+    # nx.draw_networkx_labels(graph, pos, labels=node_labels)
+
+    # edge labels
+    edge_labels = nx.get_edge_attributes(subgraph, 'lines')
+    nx.draw_networkx_edge_labels(
+        subgraph, pos,
+        edge_labels=edge_labels,
+        font_color='blue'
+    )
+    # plt.axis('off')
+    plt.show()
+    return graph
+
+def get_ast_structure_str(ast):
+    normal_stdout = sys.stdout
+    # put the string output to a string buffer
+    result = StringIO()
+    sys.stdout = result
+
+    # traverse the ast
+    ast.show(buf=sys.stdout)
+
+    # Redirect std output to the normal mode
+    sys.stdout = normal_stdout
+
+    # Get the result out
+    ast_str = result.getvalue()
+    # print('ast str = ', ast_str, '\n ast end')
+    return ast_str
+
+def generate_top_logic_graph(filelist: list[str]):
+    for f in filelist:
+        if not os.path.exists(f):
+            raise IOError("file not found: " + f)
+
+    ast, directives = parse(filelist,
+                            preprocess_include=[],
+                            preprocess_define=[])
+
+    # ast_str = get_ast_structure_str(ast)
+    return create_graph_from_ast(ast, display=False, display_signal_only=False)
+
+def main():
+    INFO = "Verilog code parser"
+    VERSION = pyverilog.__version__
+    USAGE = "Usage: python example_parser.py file ..."
+
+    def showVersion():
+        print(INFO)
+        print(VERSION)
+        print(USAGE)
+        sys.exit()
+
+    optparser = OptionParser()
+    optparser.add_option("-v", "--version", action="store_true", dest="showversion",
+                         default=False, help="Show the version")
+    optparser.add_option("-I", "--include", dest="include", action="append",
+                         default=[], help="Include path")
+    optparser.add_option("-D", dest="define", action="append",
+                         default=[], help="Macro Definition")
+    (options, args) = optparser.parse_args()
+
+    filelist = args
+    # print(filelist)
+    if options.showversion:
+        showVersion()
+
+    for f in filelist:
+        if not os.path.exists(f):
+            raise IOError("file not found: " + f)
+
+    if len(filelist) == 0:
+        showVersion()
+
+    ast, directives = parse(filelist,
+                            preprocess_include=options.include,
+                            preprocess_define=options.define)
+
+    # ast_str = get_ast_structure_str(ast)
+    create_graph_from_ast(ast, display_signal_only=True, display=True)
+    ast.show(attrnames=True)
+
+
+
+if __name__ == '__main__':
+    main()

tools/waveform_trace/src/pyverilog/Makefile

@@ -0,0 +1,8 @@
+.PHONY: clean
+clean:
+	make clean -C ./utils
+	make clean -C ./vparser
+	make clean -C ./dataflow
+	make clean -C ./controlflow
+	make clean -C ./ast_code_generator
+	rm -rf *.pyc __pycache__ *.out parsetab.py *.html

tools/waveform_trace/src/pyverilog/VERSION

@@ -0,0 +1 @@
+1.3.0

tools/waveform_trace/src/pyverilog/__init__.py

@@ -0,0 +1,7 @@
+from __future__ import absolute_import
+from __future__ import print_function
+
+import os
+
+with open(os.path.join(os.path.dirname(__file__), "VERSION")) as f:
+    __version__ = f.read().splitlines()[0]

tools/waveform_trace/src/pyverilog/ast_code_generator/Makefile

@@ -0,0 +1,3 @@
+.PHONY: clean
+clean:
+	rm -rf *.pyc __pycache__ parsetab.py *.out

tools/waveform_trace/src/pyverilog/ast_code_generator/list_ast.txt

@@ -0,0 +1,104 @@
+Source
+Description
+ModuleDef
+Paramlist
+Portlist
+Port
+Width
+Length
+Dimensions
+Identifier
+Value
+Constant
+IntConst
+FloatConst
+StringConst
+Variable
+Input
+Output
+Inout
+Tri
+Wire
+Reg
+Integer
+Real
+Genvar
+Ioport
+Parameter
+Localparam
+Decl
+Concat
+LConcat
+Repeat
+Partselect
+Pointer
+Lvalue
+Rvalue
+Operator
+UnaryOperator
+Uminus
+Ulnot
+Unot
+Uand
+Unand
+Uor
+Unor
+Uxor
+Uxnor
+Power
+Times
+Divide
+Mod
+Plus
+Minus
+Sll
+Srl
+Sra
+LessThan
+GreaterThan
+LessEq
+GreaterEq
+Eq
+NotEq
+Eql
+NotEql
+And
+Xor
+Xnor
+Or
+Land
+Lor
+Cond
+Assign
+Always
+SensList
+Sens
+Substitution
+BlockingSubstitution
+NonblockingSubstitution
+IfStatement
+ForStatement
+WhileStatement
+CaseStatement
+Case
+Block
+Initial
+WaitStatement
+ForeverStatement
+DelayStatement
+InstanceList
+Instance
+ParamArg
+PortArg
+Function
+FunctionCall
+Task
+GenerateStatement
+SystemCall
+IdentifierScopeLabel
+IdentifierScope
+Pragma
+PragmaEntry
+Disable
+ParallelBlock
+SingleStatement