fix: 修复登录状态相关问题

- 修复登录时VSCode弹出"账户不一致"确认框的问题
- 添加SSE业务错误码401检测，正确触发重新登录流程
- 修复侧边栏登录状态不刷新的问题，添加onDidChangeSessions监听

src/config/settings.ts

@@ -17,6 +17,8 @@ export type ServiceTier = "lite" | "syntaxic" | "max" | "auto";
 export interface IccoderConfig {
   /** 后端服务地址 */
   backendUrl: string;
+  /** 登录页面地址 */
+  loginUrl: string;
   /** 后端服务地址（strangeLoop） */
   backendUrlStrongeLoop: string;
   /** 请求超时时间（毫秒） */
@@ -29,26 +31,29 @@ export interface IccoderConfig {
 
 /** 环境配置 */
 const ENV_CONFIG: Record<Environment, IccoderConfig> = {
-  /** 本地开发环境 */
+  /** 本地开发环境 - 通过 Gateway 路由 */
   dev: {
-    backendUrl: "http://localhost:2233",
+    backendUrl: "http://localhost:8080/iccoder",
-    backendUrlStrongeLoop: "http://192.168.1.108:2029",
+    backendUrlStrongeLoop: "http://localhost:8080",
+    loginUrl: "http://localhost/login",
     timeout: 300000,
     userId: "default-user",
     serviceTier: "max", // 默认使用 max
   },
-  /** 测试服务器环境 */
+  /** 测试服务器环境 - 通过 Gateway 路由 */
   test: {
-    backendUrl: "http://192.168.1.108:2233",
+    backendUrl: "http://192.168.1.108:2029/iccoder",
     backendUrlStrongeLoop: "http://192.168.1.108:2029",
+    loginUrl: "http://192.168.1.108:2005/login",
     timeout: 60000,
     userId: "default-user",
     serviceTier: "max",
   },
-  /** 生产环境 */
+  /** 生产环境 - 通过 Gateway 路由 */
   prod: {
-    backendUrl: "https://api.iccoder.com",
+    backendUrl: "https://api.iccoder.com/iccoder",
-    backendUrlStrongeLoop: "http://api.iccoder.com:2029",
+    backendUrlStrongeLoop: "https://api.iccoder.com",
+    loginUrl: "https://iccoder.com/login",
     timeout: 60000,
     userId: "default-user",
     serviceTier: "auto",

src/extension.ts

@@ -128,6 +128,17 @@ export function activate(context: vscode.ExtensionContext) {
     "ic-coder.login",
     async () => {
       try {
+        // 先清除 session 偏好，避免 VSCode 弹出"账户不一致"确认框
+        try {
+          await vscode.authentication.getSession("iccoder", [], {
+            clearSessionPreference: true,
+            createIfNone: false
+          });
+        } catch {
+          // 忽略错误
+        }
+
+        // 创建新 session
         await vscode.authentication.getSession("iccoder", [], { createIfNone: true });
       } catch (error) {
         vscode.window.showErrorMessage(`登录失败: ${error}`);

src/panels/ICHelperPanel.ts

@@ -10,7 +10,6 @@ import {
   handleUserAnswer,
   abortCurrentDialog,
   handlePlanAction,
-  setPendingPlanExecution,
   getCurrentTaskId,
   setLastTaskId,
 } from "../utils/messageHandler";
@@ -282,7 +281,7 @@ export async function showICHelperPanel(
           break;
         // 新增：处理用户回答
         case "submitAnswer":
-          handleUserAnswer(
+          void handleUserAnswer(
             message.askId,
             message.selected,
             message.customInput
@@ -328,26 +327,20 @@ export async function showICHelperPanel(
         // 处理计划操作（只做模式切换，响应已通过 submitAnswer 发送）
         case "planAction":
           if (message.action === "confirm") {
-            // 确认执行：切换到 Agent 模式
+            // 确认执行：切换到 Agent 模式（UI 切换）
             panel.webview.postMessage({
               command: "switchMode",
               mode: "agent",
             });
-            // 获取当前会话的 taskId，用于复用知识图谱数据
+            // 注意：不再设置待执行计划；后端 LLM 会在同一对话中自动执行计划
-            const taskId = getCurrentTaskId();
+          } else if (message.action === "modify" || message.action === "cancel") {
-            if (taskId) {
+            void handlePlanAction(
-              // 设置待执行的计划，对话结束后自动执行（复用 taskId）
+              panel,
-              setPendingPlanExecution(
+              message.action,
-                panel,
+              message.planTitle || "",
-                message.planTitle || "计划",
+              context.extensionPath,
-                context.extensionPath,
+              message.model
-                taskId
+            );
-              );
-            } else {
-              console.warn(
-                "[ICHelperPanel] 无法获取当前 taskId，知识图谱数据可能丢失"
-              );
-            }
           }
           break;
         // 添加文件上下文 - 显示工作区文件列表

src/services/apiClient.ts

@@ -2,6 +2,7 @@
  * API 客户端
  * 封装与后端的 HTTP 通信
  */
+import * as vscode from 'vscode';
 import * as https from 'https';
 import * as http from 'http';
 import { URL } from 'url';
@@ -18,6 +19,18 @@ interface RequestOptions {
   timeout?: number;
 }
 
+/**
+ * 获取当前登录的 Token
+ */
+async function getAuthToken(): Promise<string | undefined> {
+  try {
+    const session = await vscode.authentication.getSession('iccoder', [], { silent: true });
+    return session?.accessToken;
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * 发送 HTTP 请求
  */
@@ -25,6 +38,9 @@ async function request<T>(path: string, options: RequestOptions): Promise<T> {
   const url = new URL(getApiUrl(path));
   const { timeout } = getConfig();
 
+  // 自动获取 Token
+  const token = await getAuthToken();
+
   const isHttps = url.protocol === 'https:';
   const httpModule = isHttps ? https : http;
 
@@ -35,6 +51,7 @@ async function request<T>(path: string, options: RequestOptions): Promise<T> {
     method: options.method,
     headers: {
       'Content-Type': 'application/json',
+      ...(token ? { 'Authorization': `Bearer ${token}` } : {}),
       ...options.headers
     },
     timeout: options.timeout || timeout
@@ -224,3 +241,22 @@ export async function getUserInfo(): Promise<UserInfoResponse> {
     method: 'GET'
   });
 }
+
+/** 余额查询响应 */
+export interface CreditBalanceResponse {
+  success: boolean;
+  balance?: number;
+  error?: string;
+}
+
+/**
+ * 查询用户资源点余额
+ * GET /api/dialog/balance?userId=xxx
+ */
+export async function getCreditBalance(userId: string): Promise<CreditBalanceResponse> {
+  console.log('[API] 查询余额: userId=', userId);
+  return request<CreditBalanceResponse>(`/api/dialog/balance?userId=${userId}`, {
+    method: 'GET',
+    timeout: 5000
+  });
+}

src/services/creditsService.ts

@@ -0,0 +1,210 @@
+/**
+ * 资源点余额管理服务
+ * 负责缓存余额、主动查询、发送前检测
+ */
+
+import * as vscode from 'vscode';
+import * as https from 'https';
+import * as http from 'http';
+import { URL } from 'url';
+import { getStrangeLoopApiUrl } from '../config/settings';
+import { getCachedUserInfo } from './userService';
+
+/** 低余额阈值 */
+const LOW_CREDIT_THRESHOLD = 5;
+
+/** 缓存的余额 */
+let cachedBalance: number | null = null;
+
+/** 最后更新时间 */
+let lastUpdateTime: number = 0;
+
+/** 缓存有效期（5分钟） */
+const CACHE_TTL_MS = 5 * 60 * 1000;
+
+/**
+ * 更新缓存的余额（从 SSE credit_update 事件调用）
+ */
+export function updateCachedBalance(balance: number): void {
+  cachedBalance = balance;
+  lastUpdateTime = Date.now();
+  console.log('[CreditsService] 余额已更新:', balance);
+}
+
+/**
+ * 获取缓存的余额
+ */
+export function getCachedBalance(): number | null {
+  return cachedBalance;
+}
+
+/**
+ * 检查缓存是否有效
+ */
+function isCacheValid(): boolean {
+  if (cachedBalance === null) return false;
+  return Date.now() - lastUpdateTime < CACHE_TTL_MS;
+}
+
+/**
+ * StrangeLoop 余额响应类型
+ */
+interface StrangeLoopBalanceResponse {
+  userId?: number;
+  availableCredits?: number;
+  totalCredits?: number;
+  error?: string;
+  message?: string;
+}
+
+/**
+ * 主动查询余额（直接调用 StrangeLoop 接口）
+ */
+export async function fetchBalance(): Promise<number | null> {
+  try {
+    // 获取 JWT token
+    const session = await vscode.authentication.getSession('iccoder', [], { silent: true });
+    if (!session?.accessToken) {
+      console.warn('[CreditsService] 无法查询余额：未登录');
+      return null;
+    }
+
+    const token = session.accessToken;
+    console.log('[CreditsService] 开始查询余额，token 长度:', token.length);
+
+    // 直接调用 StrangeLoop 的 /api/credit/balance 接口
+    const response = await callStrangeLoopBalance(token);
+
+    if (response.availableCredits !== undefined) {
+      const balance = response.availableCredits;
+      updateCachedBalance(balance);
+      console.log('[CreditsService] 余额查询成功:', balance);
+      return balance;
+    } else {
+      console.warn('[CreditsService] 查询余额失败:', response.error || response.message);
+      return null;
+    }
+  } catch (error) {
+    console.error('[CreditsService] 查询余额异常:', error);
+    return null;
+  }
+}
+
+/**
+ * 调用 StrangeLoop 余额接口
+ */
+async function callStrangeLoopBalance(token: string): Promise<StrangeLoopBalanceResponse> {
+  const urlStr = getStrangeLoopApiUrl('/strangeloop/api/credit/balance');
+  const url = new URL(urlStr);
+
+  const isHttps = url.protocol === 'https:';
+  const httpModule = isHttps ? https : http;
+
+  // 余额查询使用固定短超时，避免阻塞发送前检查
+  const BALANCE_TIMEOUT_MS = 5000;
+
+  const requestOptions: http.RequestOptions = {
+    hostname: url.hostname,
+    port: url.port || (isHttps ? 443 : 80),
+    path: url.pathname + url.search,
+    method: 'GET',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${token}`
+    },
+    timeout: BALANCE_TIMEOUT_MS
+  };
+
+  return new Promise((resolve, reject) => {
+    const req = httpModule.request(requestOptions, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        console.log('[CreditsService] 响应状态码:', res.statusCode);
+        console.log('[CreditsService] 响应内容:', data);
+
+        try {
+          const json = JSON.parse(data);
+          if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+            resolve(json as StrangeLoopBalanceResponse);
+          } else if (res.statusCode === 401 || res.statusCode === 403) {
+            // 登录过期或无权限
+            resolve({ error: '登录已过期，请重新登录' });
+          } else {
+            resolve({ error: json.error || json.message || json.msg || `HTTP ${res.statusCode}` });
+          }
+        } catch (e) {
+          resolve({ error: `解析响应失败: ${data}` });
+        }
+      });
+    });
+
+    req.on('error', (error) => {
+      reject(error);
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('请求超时'));
+    });
+
+    req.end();
+  });
+}
+
+/**
+ * 获取当前余额（优先使用缓存，过期则主动查询）
+ */
+export async function getBalance(): Promise<number | null> {
+  if (isCacheValid()) {
+    return cachedBalance;
+  }
+  return await fetchBalance();
+}
+
+/**
+ * 检查余额是否足够发送消息
+ * @returns { allowed: boolean, balance: number | null, message?: string }
+ */
+export async function checkBalanceBeforeSend(): Promise<{
+  allowed: boolean;
+  balance: number | null;
+  message?: string;
+}> {
+  const userInfo = getCachedUserInfo();
+  if (!userInfo) {
+    // 未登录，允许发送（后端会处理）
+    return { allowed: true, balance: null };
+  }
+
+  const balance = await getBalance();
+
+  if (balance === null) {
+    // 无法获取余额，允许发送（后端会处理）
+    console.warn('[CreditsService] 无法获取余额，允许发送');
+    return { allowed: true, balance: null };
+  }
+
+  if (balance < LOW_CREDIT_THRESHOLD) {
+    return {
+      allowed: false,
+      balance,
+      message: `资源点余额不足！当前余额 ${balance.toFixed(2)} 点，低于最低要求 ${LOW_CREDIT_THRESHOLD} 点。请充值后再试。`
+    };
+  }
+
+  return { allowed: true, balance };
+}
+
+/**
+ * 清除缓存（登出时调用）
+ */
+export function clearBalanceCache(): void {
+  cachedBalance = null;
+  lastUpdateTime = 0;
+  console.log('[CreditsService] 余额缓存已清除');
+}

src/services/dialogService.ts

@@ -12,12 +12,14 @@ 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';
+import { getUserIdFromToken, isTokenExpired } from '../utils/jwtUtils';
+import { updateCachedBalance } from './creditsService';
 
 /**
  * 消息段落类型
  */
 export interface MessageSegment {
-  type: 'text' | 'tool' | 'question' | 'agent' | 'plan';
+  type: 'text' | 'tool' | 'question' | 'agent' | 'plan' | 'progress';
   content?: string;
   toolName?: string;
   toolStatus?: 'running' | 'success' | 'error';
@@ -32,8 +34,11 @@ export interface MessageSegment {
   agentSteps?: AgentStep[];
   // 计划相关字段
   planTitle?: string;
+  planPhases?: import('../types/api').PlanPhase[];
   planSteps?: string[];
   planSummary?: string;
+  // 进度条相关字段（独立于 plan，用于执行模式）
+  progressPhases?: import('../types/api').PlanPhase[];
 }
 
 /**
@@ -62,7 +67,7 @@ export interface DialogCallbacks {
   /** 工具确认请求（Ask 模式） */
   onToolConfirm?: (confirmId: number, toolName: string, toolInput: Record<string, unknown>) => void;
   /** 计划确认请求（Plan 模式） */
-  onPlanConfirm?: (confirmId: number, title: string, steps: string[], summary: string) => void;
+  onPlanConfirm?: (confirmId: number, title: string, phases: import('../types/api').PlanPhase[] | undefined, steps: string[] | undefined, summary: string) => void;
   /** 显示问题（ask_user） */
   onQuestion?: (askId: string, question: string, options: string[]) => void;
   /** 实时更新段落（流式过程中） */
@@ -75,6 +80,8 @@ export interface DialogCallbacks {
   onNotification?: (message: string) => void;
   /** 上下文使用量更新 */
   onContextUsage?: (data: { currentTokens: number; maxTokens: number; percentage: number }) => void;
+  /** 阶段进度更新 */
+  onPhaseProgress?: (phaseId: string, status: string) => void;
 }
 
 /**
@@ -86,8 +93,10 @@ export class DialogSession {
   private toolContext: ToolExecutorContext;
   private accumulatedText = '';
   private isActive = false;
+  private hasCompleted = false;  // 标记是否已收到 complete 事件
   private segments: MessageSegment[] = [];
   private currentTextSegment: MessageSegment | null = null;
+  private completeCallback: ((segments: MessageSegment[]) => void) | null = null;  // 保存完成回调，用于 abort 时触发
 
   constructor(extensionPath: string, existingTaskId?: string) {
     // 支持复用现有 taskId（用于 Plan 模式确认后继续执行）
@@ -325,12 +334,50 @@ export class DialogSession {
     }
 
     this.isActive = true;
+    this.hasCompleted = false;  // 重置完成标志
     this.accumulatedText = '';
     this.segments = [];
     this.currentTextSegment = null;
+    this.completeCallback = callbacks.onComplete || null;  // 保存完成回调，用于 abort 时触发
 
     const config = getConfig();
 
+    // 从登录 session 获取真实 userId 和 token
+    let userId = config.userId;  // 默认值
+    let token: string | undefined;
+    try {
+      console.log('[DialogSession] 尝试获取登录 session...');
+      const session = await vscode.authentication.getSession('iccoder', [], { silent: true });
+      console.log('[DialogSession] session 结果:', session ? '已获取' : 'null/undefined');
+      if (session?.accessToken) {
+        console.log('[DialogSession] accessToken 长度:', session.accessToken.length);
+
+        // 检测 token 是否过期
+        const expired = isTokenExpired(session.accessToken);
+        if (expired === true) {
+          console.error('[DialogSession] token 已过期，需要重新登录');
+          vscode.window.showErrorMessage('登录已过期，请重新登录', '重新登录').then(selection => {
+            if (selection === '重新登录') {
+              vscode.commands.executeCommand('iccoder.login');
+            }
+          });
+          throw new Error('登录已过期，请重新登录');
+        }
+
+        token = session.accessToken;  // 保存 token 用于扣费
+        const parsedUserId = getUserIdFromToken(session.accessToken);
+        console.log('[DialogSession] 解析的 userId:', parsedUserId);
+        if (parsedUserId) {
+          userId = parsedUserId;
+          console.log('[DialogSession] 使用真实 userId:', userId);
+        }
+      } else {
+        console.log('[DialogSession] 未获取到 accessToken，使用默认 userId:', userId);
+      }
+    } catch (error) {
+      console.warn('[DialogSession] 获取登录 session 失败:', error);
+    }
+
     // 获取压缩数据和新消息（用于后端重启后恢复）
     const historyManager = ChatHistoryManager.getInstance();
     const compactedData = await historyManager.loadCompactedData(this.taskId);
@@ -340,12 +387,15 @@ export class DialogSession {
     const knowledgeData = await this.loadKnowledgeData();
     console.log('[DialogSession] knowledgeData 加载结果:', knowledgeData ? `${knowledgeData.length} 字符` : 'null');
 
+    console.log('[DialogSession] serviceTier 参数:', serviceTier, '-> 使用:', serviceTier || config.serviceTier);
+
     const request: DialogRequest = {
       taskId: this.taskId,
       message,
-      userId: config.userId,
+      userId,
       mode: mode || 'agent',
       serviceTier: serviceTier || config.serviceTier,  // 优先使用传入的参数
+      token,  // JWT token 用于扣费
       compactedData: compactedData || undefined,
       newMessages: newMessages.length > 0 ? newMessages : undefined,
       knowledgeData: knowledgeData || undefined
@@ -426,6 +476,8 @@ export class DialogSession {
         callbacks.onToolComplete?.(data.tool_name, data.result);
         // 实时发送段落更新
         callbacks.onSegmentUpdate?.(this.segments);
+        // 追踪工具执行结果（用于后端重启后恢复）
+        historyManager.trackToolResult(data.tool_name, data.result);
       },
 
       onToolError: (data) => {
@@ -433,6 +485,8 @@ export class DialogSession {
         callbacks.onToolError?.(data.tool_name, data.error);
         // 实时发送段落更新
         callbacks.onSegmentUpdate?.(this.segments);
+        // 追踪工具执行错误（用于后端重启后恢复）
+        historyManager.trackToolResult(data.tool_name, `[错误] ${data.error}`);
       },
 
       onToolConfirm: async (data: ToolConfirmEvent) => {
@@ -508,10 +562,12 @@ export class DialogSession {
         const askId = `ask_${data.confirmId}`;
 
         // 添加计划段落到聊天界面（包含 askId 用于响应）
+        // 支持新格式（phases）和旧格式（steps）
         this.segments.push({
           type: 'plan',
           askId: askId,
           planTitle: data.title,
+          planPhases: data.phases,
           planSteps: data.steps,
           planSummary: data.summary
         });
@@ -532,7 +588,108 @@ export class DialogSession {
         }
 
         // 调用回调通知 UI
-        callbacks.onPlanConfirm?.(data.confirmId, data.title, data.steps, data.summary);
+        callbacks.onPlanConfirm?.(data.confirmId, data.title, data.phases, data.steps, data.summary);
+      },
+
+      onPhaseProgress: (data: import('../types/api').PhaseProgressEvent) => {
+        console.log('[DialogSession] onPhaseProgress:', data.phaseId, data.status);
+
+        // 1. 尝试更新 plan segment（兼容旧逻辑）
+        for (let i = this.segments.length - 1; i >= 0; i--) {
+          const seg = this.segments[i];
+          if (seg.type === 'plan' && seg.planPhases) {
+            seg.planPhases = seg.planPhases.map(phase => {
+              if (phase.id === data.phaseId) {
+                return { ...phase, status: data.status };
+              }
+              return phase;
+            });
+            callbacks.onSegmentUpdate?.(this.segments);
+            break;
+          }
+        }
+
+        // 2. 通知外部更新独立进度条
+        callbacks.onPhaseProgress?.(data.phaseId, data.status);
+      },
+
+      onPlanStepAdd: (data: import('../types/api').PlanStepAddEvent) => {
+        console.log('[DialogSession] onPlanStepAdd:', data.phaseId, data.step);
+
+        for (let i = this.segments.length - 1; i >= 0; i--) {
+          const seg = this.segments[i];
+          if (seg.type === 'plan' && seg.planPhases) {
+            seg.planPhases = seg.planPhases.map(phase => {
+              if (phase.id === data.phaseId) {
+                const newSteps = [...(phase.steps || [])];
+                if (data.index >= 0 && data.index < newSteps.length) {
+                  newSteps.splice(data.index, 0, data.step);
+                } else {
+                  newSteps.push(data.step);
+                }
+                return { ...phase, steps: newSteps };
+              }
+              return phase;
+            });
+            break;
+          }
+        }
+        callbacks.onSegmentUpdate?.(this.segments);
+      },
+
+      onPlanStepRemove: (data: import('../types/api').PlanStepRemoveEvent) => {
+        console.log('[DialogSession] onPlanStepRemove:', data.phaseId, data.stepIndex);
+
+        for (let i = this.segments.length - 1; i >= 0; i--) {
+          const seg = this.segments[i];
+          if (seg.type === 'plan' && seg.planPhases) {
+            seg.planPhases = seg.planPhases.map(phase => {
+              if (phase.id === data.phaseId && phase.steps) {
+                const newSteps = [...phase.steps];
+                newSteps.splice(data.stepIndex, 1);
+                return { ...phase, steps: newSteps };
+              }
+              return phase;
+            });
+            break;
+          }
+        }
+        callbacks.onSegmentUpdate?.(this.segments);
+      },
+
+      onPlanStepUpdate: (data: import('../types/api').PlanStepUpdateEvent) => {
+        console.log('[DialogSession] onPlanStepUpdate:', data.phaseId, data.stepIndex);
+
+        for (let i = this.segments.length - 1; i >= 0; i--) {
+          const seg = this.segments[i];
+          if (seg.type === 'plan' && seg.planPhases) {
+            seg.planPhases = seg.planPhases.map(phase => {
+              if (phase.id === data.phaseId && phase.steps) {
+                const newSteps = [...phase.steps];
+                if (data.stepIndex >= 0 && data.stepIndex < newSteps.length) {
+                  newSteps[data.stepIndex] = data.step;
+                }
+                return { ...phase, steps: newSteps };
+              }
+              return phase;
+            });
+            break;
+          }
+        }
+        callbacks.onSegmentUpdate?.(this.segments);
+      },
+
+      onPlanSummaryUpdate: (data: import('../types/api').PlanSummaryUpdateEvent) => {
+        console.log('[DialogSession] onPlanSummaryUpdate');
+
+        for (let i = this.segments.length - 1; i >= 0; i--) {
+          const seg = this.segments[i];
+          if (seg.type === 'plan') {
+            seg.planSummary = data.summary;
+            break;
+          }
+        }
+        callbacks.onSegmentUpdate?.(this.segments);
       },
 
       onAskUser: async (data: AskUserEvent) => {
@@ -556,6 +713,7 @@ export class DialogSession {
 
       onComplete: (data) => {
         this.isActive = false;
+        this.hasCompleted = true;  // 标记已收到 complete 事件
         this.finalizeTextSegment();
 
         // 追踪 AI 消息（用于后端重启后恢复）
@@ -569,6 +727,18 @@ export class DialogSession {
 
       onError: (data) => {
         this.isActive = false;
+
+        // 检测登录状态过期（只弹一次窗，不再传递错误）
+        if (data.message.includes('LOGIN_EXPIRED') || data.message.includes('登录状态已过期')) {
+          vscode.window.showErrorMessage('登录状态已过期，请重新登录', '重新登录').then(selection => {
+            if (selection === '重新登录') {
+              vscode.commands.executeCommand('ic-coder.login');
+            }
+          });
+          // 登录过期错误已处理，不再传递给外部
+          return;
+        }
+
         callbacks.onError?.(data.message);
       },
 
@@ -654,12 +824,40 @@ export class DialogSession {
         callbacks.onContextUsage?.(data);
       },
 
+      onCreditUpdate: (data) => {
+        console.log('[DialogSession] onCreditUpdate: 扣除', data.deductedCredits, '剩余', data.remainingCredits);
+        // 更新余额缓存
+        updateCachedBalance(data.remainingCredits);
+        // 资源点余额低于阈值时弹窗提醒
+        const LOW_CREDIT_THRESHOLD = 5;
+        if (data.remainingCredits < LOW_CREDIT_THRESHOLD) {
+          vscode.window.showWarningMessage(
+            `资源点余额不足！当前剩余 ${data.remainingCredits.toFixed(2)} 点，请及时充值。`,
+            '去充值'
+          ).then(selection => {
+            if (selection === '去充值') {
+              // 打开充值页面
+              vscode.env.openExternal(vscode.Uri.parse('https://iccoder.com/recharge'));
+            }
+          });
+        }
+      },
+
       onOpen: () => {
         console.log('[DialogSession] SSE 连接已建立');
       },
 
       onClose: () => {
         console.log('[DialogSession] SSE 连接已关闭');
+        // 如果没有收到 complete 事件，需要补充完成逻辑
+        if (!this.hasCompleted && this.isActive) {
+          console.log('[DialogSession] 未收到 complete 事件，补充完成处理');
+          this.finalizeTextSegment();
+          if (this.accumulatedText) {
+            historyManager.trackAiMessage(this.accumulatedText);
+          }
+          callbacks.onComplete?.(this.segments);
+        }
         this.isActive = false;
       }
     };
@@ -678,13 +876,25 @@ export class DialogSession {
    * 中止当前对话
    */
   abort(): void {
+    // 先标记完成，防止 onClose 重复触发
+    const wasActive = this.isActive;
+    this.hasCompleted = true;
+    this.isActive = false;
+
     if (this.sseController) {
       this.sseController.abort();
       this.sseController = null;
     }
-    this.isActive = false;
     userInteractionManager.cancelAll();
 
+    // 如果之前是活跃状态，触发完成回调以结束 Promise
+    if (wasActive && this.completeCallback) {
+      this.finalizeTextSegment();
+      console.log('[DialogSession] abort 触发完成回调');
+      this.completeCallback(this.segments);
+      this.completeCallback = null;
+    }
+
     // 通知后端停止处理
     stopDialog(this.taskId).catch(err => {
       console.warn('[DialogSession] 停止对话请求失败:', err);
@@ -713,7 +923,10 @@ export class DialogSession {
     selected?: string[],
     customInput?: string
   ): Promise<void> {
-    await userInteractionManager.receiveAnswer(askId, selected, customInput);
+    // 直接调用 receiveAnswer，传递 taskId 作为 fallbackTaskId
+    // 如果 pendingQuestions 中有问题，走正常流程
+    // 如果没有，receiveAnswer 会使用 fallbackTaskId 直接发送到后端
+    await userInteractionManager.receiveAnswer(askId, selected, customInput, this.taskId);
   }
 }
 
@@ -749,6 +962,7 @@ class DialogManager {
    */
   abortCurrentSession(): void {
     this.currentSession?.abort();
+    this.currentSession = null;  // 清空会话，确保下次创建新会话
   }
 }
 

src/services/icCoderAuthProvider.ts

@@ -3,6 +3,7 @@ import * as http from "http";
 import * as path from "path";
 import * as fs from "fs";
 import { onTokenReceived, type UserInfo, clearUserInfo } from "./userService";
+import { getConfig } from "../config/settings";
 
 /**
  * IC Coder Authentication Provider
@@ -13,7 +14,6 @@ export class ICCoderAuthenticationProvider
 {
   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;
 
@@ -61,6 +61,20 @@ export class ICCoderAuthenticationProvider
     scopes: readonly string[]
   ): Promise<vscode.AuthenticationSession> {
     try {
+      // 先删除旧的 session（静默删除，不弹窗、不重载窗口）
+      if (this._sessions.length > 0) {
+        const oldSession = this._sessions[0];
+        this._sessions = [];
+        await this.saveSessions();
+        await clearUserInfo();
+        this._onDidChangeSessions.fire({
+          added: [],
+          removed: [oldSession],
+          changed: [],
+        });
+        console.log("🔄 已清除旧的 session");
+      }
+
       const token = await this.login();
 
       // 获取到 token 后立即调用用户信息接口
@@ -156,9 +170,8 @@ export class ICCoderAuthenticationProvider
 
     // 构建登录 URL
     const callbackUrl = `http://localhost:${port}/callback`;
-    const loginUrl = `${
+    const config = getConfig();
-      ICCoderAuthenticationProvider.LOGIN_URL
+    const loginUrl = `${config.loginUrl}?redirect_uri=${encodeURIComponent(callbackUrl)}`;
-    }?redirect_uri=${encodeURIComponent(callbackUrl)}`;
 
     console.log("🔐 登录服务器已启动，监听端口:", port);
     console.log("🌐 登录 URL:", loginUrl);

src/services/sseHandler.ts

@@ -28,7 +28,8 @@ import type {
   AgentProgressEvent,
   AgentCompleteEvent,
   AgentErrorEvent,
-  ContextUsageEvent
+  ContextUsageEvent,
+  CreditUpdateEvent
 } from '../types/api';
 import type { MemoryCompactedEvent } from '../types/memory';
 
@@ -44,6 +45,16 @@ export interface SSECallbacks {
   onToolConfirm?: (data: ToolConfirmEvent) => void;
   /** 收到计划确认请求（Plan 模式） */
   onPlanConfirm?: (data: PlanConfirmEvent) => void;
+  /** 阶段进度更新 */
+  onPhaseProgress?: (data: import('../types/api').PhaseProgressEvent) => void;
+  /** 添加计划步骤 */
+  onPlanStepAdd?: (data: import('../types/api').PlanStepAddEvent) => void;
+  /** 删除计划步骤 */
+  onPlanStepRemove?: (data: import('../types/api').PlanStepRemoveEvent) => void;
+  /** 更新计划步骤 */
+  onPlanStepUpdate?: (data: import('../types/api').PlanStepUpdateEvent) => void;
+  /** 更新计划摘要 */
+  onPlanSummaryUpdate?: (data: import('../types/api').PlanSummaryUpdateEvent) => void;
   /** 工具开始执行 */
   onToolStart?: (data: ToolStartEvent) => void;
   /** 工具执行完成 */
@@ -74,6 +85,8 @@ export interface SSECallbacks {
   onMemoryCompacted?: (data: MemoryCompactedEvent) => void;
   /** 上下文使用量更新 */
   onContextUsage?: (data: ContextUsageEvent) => void;
+  /** 资源点余额更新 */
+  onCreditUpdate?: (data: CreditUpdateEvent) => void;
   /** 连接打开 */
   onOpen?: () => void;
   /** 连接关闭 */
@@ -160,7 +173,8 @@ export async function startStreamDialog(
         'Content-Type': 'application/json',
         'Accept': 'text/event-stream',
         'Cache-Control': 'no-cache',
-        'Content-Length': Buffer.byteLength(body)
+        'Content-Length': Buffer.byteLength(body),
+        ...(request.token ? { 'Authorization': `Bearer ${request.token}` } : {})
       }
     };
 
@@ -170,9 +184,20 @@ export async function startStreamDialog(
         let errorBody = '';
         res.on('data', chunk => errorBody += chunk);
         res.on('end', () => {
-          const error = new Error(`SSE 连接失败: ${res.statusCode} ${errorBody}`);
+          // 检测是否是登录状态过期
-          callbacks.onError?.({ message: error.message });
+          const isLoginExpired = errorBody.includes('登录状态已过期') ||
-          reject(error);
+                                 errorBody.includes('token') && errorBody.includes('过期') ||
+                                 res.statusCode === 401;
+
+          if (isLoginExpired) {
+            const error = new Error('LOGIN_EXPIRED:登录状态已过期，请重新登录');
+            callbacks.onError?.({ message: error.message });
+            reject(error);
+          } else {
+            const error = new Error(`SSE 连接失败: ${res.statusCode} ${errorBody}`);
+            callbacks.onError?.({ message: error.message });
+            reject(error);
+          }
         });
         return;
       }
@@ -213,6 +238,25 @@ export async function startStreamDialog(
       res.on('data', (chunk: string) => {
         if (!controller.aborted) {
           console.log('[SSE] 收到原始数据块:', chunk.substring(0, 200));
+
+          // 检查是否是业务错误码（Gateway 返回 HTTP 200 但响应体是错误 JSON）
+          try {
+            const trimmed = chunk.trim();
+            if (trimmed.startsWith('{') && trimmed.includes('"code"')) {
+              const json = JSON.parse(trimmed);
+              if (json.code === 401 || json.msg?.includes('登录状态已过期')) {
+                console.log('[SSE] 检测到登录过期业务错误');
+                const error = new Error('LOGIN_EXPIRED:登录状态已过期，请重新登录');
+                callbacks.onError?.({ message: error.message });
+                controller.abort();
+                reject(error);
+                return;
+              }
+            }
+          } catch {
+            // 不是 JSON 格式，继续正常处理
+          }
+
           parser.feed(chunk);
         }
       });
@@ -286,6 +330,21 @@ function dispatchEvent(
     case 'plan_confirm':
       callbacks.onPlanConfirm?.(data as PlanConfirmEvent);
       break;
+    case 'phase_progress':
+      callbacks.onPhaseProgress?.(data as import('../types/api').PhaseProgressEvent);
+      break;
+    case 'plan_step_add':
+      callbacks.onPlanStepAdd?.(data as import('../types/api').PlanStepAddEvent);
+      break;
+    case 'plan_step_remove':
+      callbacks.onPlanStepRemove?.(data as import('../types/api').PlanStepRemoveEvent);
+      break;
+    case 'plan_step_update':
+      callbacks.onPlanStepUpdate?.(data as import('../types/api').PlanStepUpdateEvent);
+      break;
+    case 'plan_summary_update':
+      callbacks.onPlanSummaryUpdate?.(data as import('../types/api').PlanSummaryUpdateEvent);
+      break;
     case 'tool_start':
       callbacks.onToolStart?.(data as ToolStartEvent);
       break;
@@ -331,6 +390,9 @@ function dispatchEvent(
     case 'context_usage':
       callbacks.onContextUsage?.(data as ContextUsageEvent);
       break;
+    case 'credit_update':
+      callbacks.onCreditUpdate?.(data as CreditUpdateEvent);
+      break;
     case 'heartbeat':
       // 心跳事件：仅用于保持连接，不需要特殊处理
       // Node.js req.setTimeout 会在收到数据时自动重置计时器

src/services/toolExecutor.ts

@@ -8,7 +8,7 @@ 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 { generateVCD, checkIverilogAvailable, generateMultiVCD, DumpModule } from '../utils/iverilogRunner';
 import { analyzeVcdFile } from '../utils/vcdParser';
 import { executeWaveformTrace, WaveformTraceArgs } from '../utils/waveformTracer';
 import {
@@ -25,6 +25,7 @@ import type {
   FileDeleteArgs,
   FileListArgs,
   SyntaxCheckArgs,
+  IverilogArgs,
   SimulationArgs,
   WaveformSummaryArgs,
   KnowledgeSaveArgs,
@@ -75,6 +76,9 @@ export async function executeToolCall(
       case 'syntax_check':
         resultText = await executeSyntaxCheck(args as unknown as SyntaxCheckArgs, context);
         break;
+      case 'iverilog':
+        resultText = await executeIverilog(args as unknown as IverilogArgs, context);
+        break;
       case 'simulation':
         resultText = await executeSimulation(args as unknown as SimulationArgs, context);
         break;
@@ -270,6 +274,71 @@ async function executeSyntaxCheck(
   }
 }
 
+/**
+ * 执行 iverilog 工具
+ * 直接执行 iverilog 命令
+ */
+async function executeIverilog(
+  args: IverilogArgs,
+  context: ToolExecutorContext
+): Promise<string> {
+  // 检查 iverilog 是否可用
+  const iverilogCheck = await checkIverilogAvailable(context.extensionPath);
+  if (!iverilogCheck.available) {
+    throw new Error(`iverilog 不可用: ${iverilogCheck.message}`);
+  }
+
+  // 获取工作目录
+  const workspaceFolders = vscode.workspace.workspaceFolders;
+  if (!workspaceFolders || workspaceFolders.length === 0) {
+    throw new Error('没有打开的工作区');
+  }
+  const projectPath = workspaceFolders[0].uri.fsPath;
+  const workDir = args.workDir
+    ? path.join(projectPath, args.workDir)
+    : projectPath;
+
+  // 解析参数
+  const iverilogPath = getIverilogPath(context.extensionPath);
+  const cmdArgs = args.args.split(/\s+/).filter(a => a.length > 0);
+
+  const { spawn } = require('child_process');
+
+  return new Promise((resolve, reject) => {
+    const child = spawn(iverilogPath, cmdArgs, {
+      cwd: workDir,
+      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) => {
+      const output = stderr || stdout || '(无输出)';
+      if (code === 0) {
+        resolve(`执行成功\n${output}`);
+      } else {
+        resolve(`执行失败 (exit code: ${code})\n${output}`);
+      }
+    });
+
+    child.on('error', (error: Error) => {
+      reject(error);
+    });
+  });
+}
+
 /**
  * 执行 simulation 工具
  */
@@ -285,7 +354,30 @@ async function executeSimulation(
 
   const projectPath = workspaceFolders[0].uri.fsPath;
 
-  // 调用现有的 generateVCD 函数
+  // 检查是否有 dumpModules 参数（多 VCD 模式）
+  if (args.dumpModules) {
+    const modules = parseDumpModules(args.dumpModules);
+    const vcdDir = args.vcdDir || 'vcd';
+
+    const result = await generateMultiVCD(
+      projectPath,
+      context.extensionPath,
+      args.tbPath,
+      modules,
+      vcdDir
+    );
+
+    if (result.success) {
+      const vcdList = result.vcdFiles
+        .map(f => `- ${f.moduleName}: ${f.success ? f.vcdPath : '失败 - ' + f.error}`)
+        .join('\n');
+      return `${result.message}\n\nVCD 文件列表:\n${vcdList}${result.stdout ? '\n\n仿真输出:' + result.stdout : ''}`;
+    } else {
+      throw new Error(result.message);
+    }
+  }
+
+  // 原有单 VCD 逻辑
   const result = await generateVCD(projectPath, context.extensionPath);
 
   if (result.success) {
@@ -303,6 +395,17 @@ async function executeSimulation(
   }
 }
 
+/**
+ * 解析 dumpModules 参数
+ * 格式：name:path,name:path
+ */
+function parseDumpModules(dumpModules: string): DumpModule[] {
+  return dumpModules.split(',').map(item => {
+    const [name, modulePath] = item.trim().split(':');
+    return { name: name.trim(), path: modulePath.trim() };
+  });
+}
+
 /**
  * 执行 waveform_summary 工具
  * 解析 VCD 文件并返回波形摘要

src/services/userInteraction.ts

@@ -82,21 +82,28 @@ export class UserInteractionManager {
    * @param askId 问题ID
    * @param selected 选中的选项
    * @param customInput 自定义输入
+   * @param fallbackTaskId 当问题不存在时使用的 taskId（用于直接发送到后端）
    */
   async receiveAnswer(
     askId: string,
     selected?: string[],
-    customInput?: string
+    customInput?: string,
+    fallbackTaskId?: string
   ): Promise<void> {
     const pending = this.pendingQuestions.get(askId);
+    const answer = customInput || selected?.join(', ') || '';
+
     if (!pending) {
-      console.warn(`[UserInteraction] 问题不存在或已超时: askId=${askId}`);
+      // 问题不存在（可能是页面刷新或会话切换后），尝试直接发送到后端
+      if (fallbackTaskId) {
+        console.log(`[UserInteraction] 问题不在 pendingQuestions 中，直接发送到后端: askId=${askId}, taskId=${fallbackTaskId}`);
+        await this.submitUserAnswer(askId, fallbackTaskId, answer);
+      } else {
+        console.warn(`[UserInteraction] 问题不存在且无 fallbackTaskId: askId=${askId}`);
+      }
       return;
     }
 
-    // 构建答案
-    const answer = customInput || selected?.join(', ') || '';
-
     console.log(`[UserInteraction] 收到用户回答: askId=${askId}, answer=${answer}`);
 
     // 移除待处理问题
@@ -173,6 +180,13 @@ export class UserInteractionManager {
   hasPendingQuestions(): boolean {
     return this.pendingQuestions.size > 0;
   }
+
+  /**
+   * 检查特定问题是否存在
+   */
+  hasPendingQuestion(askId: string): boolean {
+    return this.pendingQuestions.has(askId);
+  }
 }
 
 // 全局实例

src/types/api.ts

@@ -40,6 +40,8 @@ export interface DialogRequest {
   mode: RunMode;
   /** 服务等级 */
   serviceTier?: ServiceTier;
+  /** JWT Token（用于认证和扣费） */
+  token?: string;
   /** 压缩后的记忆数据（用于后端重启后恢复） */
   compactedData?: CompactedMemory;
   /** 压缩后产生的新消息 */
@@ -56,6 +58,11 @@ export type SSEEventType =
   | "tool_call" // 客户端工具调用请求
   | "tool_confirm" // 工具确认请求（Ask 模式）
   | "plan_confirm" // 计划确认请求（Plan 模式）
+  | "phase_progress" // 阶段进度更新
+  | "plan_step_add" // 添加计划步骤
+  | "plan_step_remove" // 删除计划步骤
+  | "plan_step_update" // 更新计划步骤
+  | "plan_summary_update" // 更新计划摘要
   | "tool_start" // 工具开始执行
   | "tool_complete" // 工具执行完成
   | "tool_error" // 工具执行错误
@@ -66,6 +73,7 @@ export type SSEEventType =
   | "agent_error" // 子智能体错误
   | "memory_compacted" // 记忆压缩完成
   | "context_usage" // 上下文使用量
+  | "credit_update" // 资源点余额更新
   | "complete" // 对话完成
   | "error" // 错误
   | "warning" // 警告
@@ -108,20 +116,83 @@ export interface ToolConfirmEvent {
   timestamp: number;
 }
 
+/** 计划步骤 */
+export interface PlanStep {
+  /** 步骤名称 */
+  name: string;
+  /** 步骤描述 */
+  description?: string;
+}
+
+/** 计划阶段 */
+export interface PlanPhase {
+  /** 阶段ID: spec/design/sim/done */
+  id: string;
+  /** 阶段名称 */
+  name: string;
+  /** 阶段状态: skipped/completed/current/pending */
+  status: string;
+  /** 跳过原因 */
+  reason?: string;
+  /** 阶段内的步骤 */
+  steps: PlanStep[];
+}
+
 /** plan_confirm 事件数据（Plan 模式计划确认） */
 export interface PlanConfirmEvent {
   /** 确认ID */
   confirmId: number;
   /** 计划标题 */
   title: string;
-  /** 执行步骤列表 */
+  /** 四阶段计划列表（新格式） */
-  steps: string[];
+  phases?: PlanPhase[];
+  /** 执行步骤列表（旧格式，兼容） */
+  steps?: string[];
   /** 计划摘要 */
   summary: string;
   /** 时间戳 */
   timestamp: number;
 }
 
+/** phase_progress 事件数据（阶段进度更新） */
+export interface PhaseProgressEvent {
+  /** 阶段ID: spec/design/sim/done */
+  phaseId: string;
+  /** 状态: current/completed */
+  status: string;
+  /** 时间戳 */
+  timestamp: number;
+}
+
+/** plan_step_add 事件数据（添加计划步骤） */
+export interface PlanStepAddEvent {
+  phaseId: string;
+  step: PlanStep;
+  index: number;
+  timestamp: number;
+}
+
+/** plan_step_remove 事件数据（删除计划步骤） */
+export interface PlanStepRemoveEvent {
+  phaseId: string;
+  stepIndex: number;
+  timestamp: number;
+}
+
+/** plan_step_update 事件数据（更新计划步骤） */
+export interface PlanStepUpdateEvent {
+  phaseId: string;
+  stepIndex: number;
+  step: PlanStep;
+  timestamp: number;
+}
+
+/** plan_summary_update 事件数据（更新计划摘要） */
+export interface PlanSummaryUpdateEvent {
+  summary: string;
+  timestamp: number;
+}
+
 /** ask_user 事件数据 */
 export interface AskUserEvent {
   askId: string;
@@ -201,6 +272,12 @@ export interface ContextUsageEvent {
   percentage: number;
 }
 
+/** credit_update 事件数据 */
+export interface CreditUpdateEvent {
+  deductedCredits: number;
+  remainingCredits: number;
+}
+
 // ============== 工具调用协议 (MCP 格式) ==============
 
 /**
@@ -409,6 +486,7 @@ export type ToolName =
   | "file_delete"
   | "file_list"
   | "syntax_check"
+  | "iverilog"
   | "simulation"
   | "waveform_summary"
   | "waveform_trace"
@@ -443,11 +521,21 @@ export interface SyntaxCheckArgs {
   code: string;
 }
 
+/** iverilog 工具参数 */
+export interface IverilogArgs {
+  args: string;
+  workDir?: string;
+}
+
 /** simulation 工具参数 */
 export interface SimulationArgs {
   rtlPath: string;
   tbPath: string;
   duration?: string;
+  /** 要dump的模块列表，格式：name:path,name:path */
+  dumpModules?: string;
+  /** VCD输出目录，默认'vcd' */
+  vcdDir?: string;
 }
 
 /** waveform_summary 工具参数 */
@@ -487,6 +575,7 @@ export type ToolArgs =
   | FileDeleteArgs
   | FileListArgs
   | SyntaxCheckArgs
+  | IverilogArgs
   | SimulationArgs
   | WaveformSummaryArgs
   | WaveformTraceArgs

src/utils/chatHistoryManager.ts

@@ -715,6 +715,10 @@ export class ChatHistoryManager {
 
     if (!projectPath) {
       console.error('[ChatHistoryManager] 无法保存压缩数据：projectPath 为空');
+      // 通知用户压缩数据保存失败
+      vscode.window.showWarningMessage(
+        '对话历史压缩数据保存失败：无法确定项目路径。后端重启后可能无法恢复完整对话历史。'
+      );
       return;
     }
 
@@ -731,6 +735,19 @@ export class ChatHistoryManager {
       // 文件不存在，使用空数组
     }
 
+    // 版本检查：防止旧版本覆盖新版本（从尾部扫描，与加载逻辑一致）
+    let existingSummary: CompactionSummaryMessage | null = null;
+    for (let i = messages.length - 1; i >= 0; i--) {
+      if (messages[i].type === MessageType.COMPACTION_SUMMARY) {
+        existingSummary = messages[i] as CompactionSummaryMessage;
+        break;
+      }
+    }
+    if (existingSummary && existingSummary.version >= compacted.version) {
+      console.log(`[ChatHistoryManager] 跳过旧版本压缩数据: 现有版本=${existingSummary.version}, 新版本=${compacted.version}`);
+      return;
+    }
+
     // 创建压缩摘要消息
     const summaryMessage: CompactionSummaryMessage = {
       type: MessageType.COMPACTION_SUMMARY,
@@ -893,4 +910,14 @@ export class ChatHistoryManager {
       content: text
     });
   }
+
+  /**
+   * 追踪新消息（工具执行结果）
+   */
+  public trackToolResult(toolName: string, result: string): void {
+    this.newMessagesSinceCompaction.push({
+      type: 'TOOL_RESULT',
+      content: `[${toolName}] ${result}`
+    });
+  }
 }

src/utils/iverilogRunner.ts

@@ -413,3 +413,193 @@ export async function checkIverilogAvailable(
     };
   }
 }
+
+/**
+ * 要 dump 的模块定义
+ */
+export interface DumpModule {
+  name: string;   // 模块名（用于 VCD 文件名和宏名）
+  path: string;   // 实例路径（如 dut.u_tx）
+}
+
+/**
+ * 多 VCD 生成结果
+ */
+export interface MultiVCDResult {
+  success: boolean;
+  vcdFiles: Array<{
+    moduleName: string;
+    vcdPath: string;
+    success: boolean;
+    error?: string;
+  }>;
+  message: string;
+  stdout?: string;
+}
+
+/**
+ * 在 testbench 中注入条件编译代码
+ * 将原有的 $dumpfile/$dumpvars 替换为条件编译版本
+ */
+function injectConditionalDump(
+  tbContent: string,
+  dumpModules: DumpModule[],
+  vcdDir: string
+): string {
+  // 匹配 $dumpfile 和 $dumpvars 语句（可能跨多行）
+  const dumpPattern = /(\$dumpfile\s*\([^)]+\)\s*;[\s\S]*?\$dumpvars\s*\([^)]+\)\s*;)/g;
+
+  // 生成条件编译代码
+  const conditionalCode = generateConditionalDumpCode(dumpModules, vcdDir);
+
+  // 替换原有的 dump 语句
+  const modified = tbContent.replace(dumpPattern, conditionalCode);
+
+  // 如果没有找到匹配，尝试单独匹配 $dumpfile
+  if (modified === tbContent) {
+    const singleDumpPattern = /\$dumpfile\s*\([^)]+\)\s*;/g;
+    return tbContent.replace(singleDumpPattern, conditionalCode);
+  }
+
+  return modified;
+}
+
+/**
+ * 生成条件编译的 dump 代码
+ */
+function generateConditionalDumpCode(
+  dumpModules: DumpModule[],
+  vcdDir: string
+): string {
+  if (dumpModules.length === 0) {
+    return '$dumpfile("output.vcd");\n    $dumpvars(0, dut);';
+  }
+
+  const lines: string[] = [];
+
+  dumpModules.forEach((module, index) => {
+    const macroName = `DUMP_${module.name.toUpperCase()}`;
+    const vcdPath = `${vcdDir}/${module.name}.vcd`;
+    const directive = index === 0 ? '`ifdef' : '`elsif';
+
+    lines.push(`${directive} ${macroName}`);
+    lines.push(`    $dumpfile("${vcdPath}");`);
+    lines.push(`    $dumpvars(1, ${module.path});`);
+  });
+
+  // 添加默认分支（使用第一个模块）
+  lines.push('`else');
+  lines.push(`    $dumpfile("${vcdDir}/${dumpModules[0].name}.vcd");`);
+  lines.push(`    $dumpvars(1, ${dumpModules[0].path});`);
+  lines.push('`endif');
+
+  return lines.join('\n');
+}
+
+/**
+ * 生成多个 VCD 文件（为不同子模块）
+ */
+export async function generateMultiVCD(
+  projectPath: string,
+  extensionPath: string,
+  tbPath: string,
+  dumpModules: DumpModule[],
+  vcdDir: string = 'vcd'
+): Promise<MultiVCDResult> {
+  const results: MultiVCDResult['vcdFiles'] = [];
+  let allStdout = '';
+
+  try {
+    // 1. 创建 vcd 目录
+    const vcdDirPath = path.join(projectPath, vcdDir);
+    const vcdDirUri = vscode.Uri.file(vcdDirPath);
+    try {
+      await vscode.workspace.fs.createDirectory(vcdDirUri);
+    } catch {
+      // 目录可能已存在
+    }
+
+    // 2. 读取原始 testbench
+    const tbFullPath = path.isAbsolute(tbPath) ? tbPath : path.join(projectPath, tbPath);
+    const tbUri = vscode.Uri.file(tbFullPath);
+    const tbBytes = await vscode.workspace.fs.readFile(tbUri);
+    const originalTb = Buffer.from(tbBytes).toString('utf-8');
+
+    // 3. 注入条件编译代码
+    const modifiedTb = injectConditionalDump(originalTb, dumpModules, vcdDir);
+    await vscode.workspace.fs.writeFile(tbUri, Buffer.from(modifiedTb, 'utf-8'));
+
+    console.log('[generateMultiVCD] Testbench 已修改，开始多次仿真...');
+
+    // 4. 获取工具路径
+    const iverilogPath = await getIverilogPath(extensionPath);
+    const vvpPath = await getVvpPath(extensionPath);
+    const env = {
+      ...process.env,
+      IVERILOG_ROOT: path.join(extensionPath, "tools", "iverilog"),
+    };
+
+    // 5. 获取所有 Verilog 文件
+    const projectCheck = await checkVerilogProject(projectPath);
+    const outputFile = path.join(projectPath, "simulation.vvp");
+
+    // 6. 循环执行仿真
+    for (const module of dumpModules) {
+      const macroName = `DUMP_${module.name.toUpperCase()}`;
+      const vcdPath = path.join(vcdDirPath, `${module.name}.vcd`);
+
+      console.log(`[generateMultiVCD] 仿真模块: ${module.name} (${macroName})`);
+
+      try {
+        // 编译（带宏定义）
+        const compileArgs = [
+          `-D${macroName}`,
+          "-o", outputFile,
+          ...projectCheck.allVerilogFiles
+        ];
+        await execCommand(iverilogPath, compileArgs, { cwd: projectPath, env });
+
+        // 仿真
+        const simResult = await execCommand(vvpPath, [outputFile], { cwd: projectPath, env });
+        allStdout += `\n[${module.name}] ${simResult.stdout}`;
+
+        results.push({
+          moduleName: module.name,
+          vcdPath: vcdPath,
+          success: true
+        });
+      } catch (error: any) {
+        console.error(`[generateMultiVCD] 模块 ${module.name} 仿真失败:`, error.message);
+        results.push({
+          moduleName: module.name,
+          vcdPath: vcdPath,
+          success: false,
+          error: error.message
+        });
+        // 继续执行其他模块
+      }
+    }
+
+    // 7. 清理中间文件
+    try {
+      await vscode.workspace.fs.delete(vscode.Uri.file(outputFile));
+    } catch {
+      // 忽略
+    }
+
+    const successCount = results.filter(r => r.success).length;
+    return {
+      success: successCount > 0,
+      vcdFiles: results,
+      message: `生成完成：${successCount}/${dumpModules.length} 个 VCD 文件成功`,
+      stdout: allStdout
+    };
+
+  } catch (error) {
+    return {
+      success: false,
+      vcdFiles: results,
+      message: `生成多 VCD 文件失败: ${error instanceof Error ? error.message : '未知错误'}`
+    };
+  }
+}

src/utils/jwtUtils.ts

@@ -0,0 +1,101 @@
+/**
+ * JWT 工具函数
+ */
+
+/**
+ * JWT Payload 接口
+ */
+export interface JwtPayload {
+  sub?: string;      // subject (通常是 userId)
+  userId?: number;   // 用户ID (驼峰命名)
+  user_id?: number;  // 用户ID (下划线命名)
+  exp?: number;      // 过期时间
+  iat?: number;      // 签发时间
+  [key: string]: unknown;
+}
+
+/**
+ * 解析 JWT token 的 payload
+ * @param token JWT token
+ * @returns 解析后的 payload，解析失败返回 null
+ */
+export function parseJwtPayload(token: string): JwtPayload | null {
+  try {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+      console.warn('[JWT] token 格式不正确，期望3部分，实际:', parts.length);
+      return null;
+    }
+
+    // payload 是第二部分，base64url 编码
+    const payload = parts[1];
+
+    // base64url 转 base64
+    const base64 = payload.replace(/-/g, '+').replace(/_/g, '/');
+
+    // 解码
+    const jsonStr = Buffer.from(base64, 'base64').toString('utf-8');
+    const parsed = JSON.parse(jsonStr);
+
+    console.log('[JWT] 解析成功, payload 字段:', Object.keys(parsed));
+    console.log('[JWT] payload 内容:', JSON.stringify(parsed));
+    return parsed;
+  } catch (error) {
+    console.error('[JWT] 解析失败:', error);
+    return null;
+  }
+}
+
+/**
+ * 从 JWT token 中获取用户ID
+ * @param token JWT token
+ * @returns 用户ID字符串，获取失败返回 null
+ */
+export function getUserIdFromToken(token: string): string | null {
+  const payload = parseJwtPayload(token);
+  if (!payload) {
+    return null;
+  }
+
+  // 支持多种字段名：user_id, userId, sub
+  if (payload.user_id !== undefined) {
+    return String(payload.user_id);
+  }
+  if (payload.userId !== undefined) {
+    return String(payload.userId);
+  }
+  if (payload.sub !== undefined) {
+    return String(payload.sub);
+  }
+
+  console.warn('[JWT] payload 中没有 user_id, userId 或 sub 字段');
+  return null;
+}
+
+/**
+ * 检测 JWT token 是否已过期
+ * @param token JWT token
+ * @param bufferSeconds 提前多少秒判定为过期（默认60秒）
+ * @returns true 表示已过期，false 表示未过期，null 表示无法判断
+ */
+export function isTokenExpired(token: string, bufferSeconds: number = 60): boolean | null {
+  const payload = parseJwtPayload(token);
+  if (!payload) {
+    return null;
+  }
+
+  if (payload.exp === undefined) {
+    console.warn('[JWT] payload 中没有 exp 字段，无法判断过期');
+    return null;
+  }
+
+  const now = Math.floor(Date.now() / 1000);
+  const expTime = payload.exp - bufferSeconds;
+  const isExpired = now >= expTime;
+
+  if (isExpired) {
+    console.warn('[JWT] token 已过期，exp:', payload.exp, '当前:', now);
+  }
+
+  return isExpired;
+}

src/utils/messageHandler.ts

@@ -18,6 +18,7 @@ import { ChatHistoryManager } from "./chatHistoryManager";
 import { dialogManager, DialogSession } from "../services/dialogService";
 import { userInteractionManager } from "../services/userInteraction";
 import { healthCheck } from "../services/apiClient";
+import { checkBalanceBeforeSend } from "../services/creditsService";
 
 import type { RunMode, ServiceTier } from "../types/api";
 
@@ -30,27 +31,6 @@ 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);
-}
-
 /**
  * 处理用户消息
  */
@@ -88,6 +68,27 @@ export async function handleUserMessage(
     return;
   }
 
+  // 发送前检测余额
+  const balanceCheck = await checkBalanceBeforeSend();
+  if (!balanceCheck.allowed) {
+    console.warn("[MessageHandler] 余额不足，阻止发送:", balanceCheck.message);
+    // 显示错误提示
+    const selection = await vscode.window.showWarningMessage(
+      balanceCheck.message || "资源点余额不足",
+      "去充值"
+    );
+    if (selection === "去充值") {
+      vscode.env.openExternal(vscode.Uri.parse("https://iccoder.com/recharge"));
+    }
+    // 恢复输入状态
+    panel.webview.postMessage({
+      command: "updateSegments",
+      segments: [],
+      isComplete: true,
+    });
+    return;
+  }
+
   // 尝试使用后端服务
   if (useBackendService && extensionPath) {
     try {
@@ -135,13 +136,11 @@ async function handleUserMessageWithBackend(
   // 优先使用 reuseTaskId，其次使用 historyManager 的 taskId
   const taskIdToUse = reuseTaskId || historyManager.getCurrentTaskId();
 
-  // 创建或复用会话
+  // 创建会话（dialogManager 会自动处理旧会话的中止）
-  if (!currentSession || !currentSession.active) {
+  currentSession = dialogManager.createSession(extensionPath, taskIdToUse || undefined);
-    currentSession = dialogManager.createSession(extensionPath, taskIdToUse || undefined);
+  // 保存 taskId 用于后续操作（如压缩）
-    // 保存 taskId 用于后续操作（如压缩）
+  lastTaskId = currentSession.getTaskId();
-    lastTaskId = currentSession.getTaskId();
+  console.log("[MessageHandler] 创建会话: taskId=", lastTaskId, "来源=", taskIdToUse ? "historyManager" : "新生成");
-    console.log("[MessageHandler] 创建会话: taskId=", lastTaskId, "来源=", taskIdToUse ? "historyManager" : "新生成");
-  }
 
   // 显示状态栏
   panel.webview.postMessage({
@@ -222,39 +221,6 @@ async function handleUserMessageWithBackend(
             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();
         },
 
@@ -288,6 +254,36 @@ async function handleUserMessageWithBackend(
             percentage: data.percentage,
           });
         },
+
+        onPhaseProgress: (phaseId, status) => {
+          // 发送阶段进度更新到 WebView
+          // 映射 phaseId: sim -> simulation
+          const stepMap: Record<string, string> = {
+            spec: "spec",
+            design: "design",
+            sim: "simulation",
+            done: "done",
+          };
+          const step = stepMap[phaseId] || phaseId;
+
+          if (status === "current") {
+            // 显示进度条并更新到当前步骤
+            panel.webview.postMessage({ type: "showProgress" });
+            panel.webview.postMessage({ type: "updateProgress", step });
+          } else if (status === "completed") {
+            // 更新到下一步（或完成）
+            const steps = ["spec", "design", "simulation", "done"];
+            const currentIndex = steps.indexOf(step);
+            if (currentIndex < steps.length - 1) {
+              panel.webview.postMessage({
+                type: "updateProgress",
+                step: steps[currentIndex + 1],
+              });
+            } else {
+              panel.webview.postMessage({ type: "completeProgress" });
+            }
+          }
+        },
       },
       mode,
       serviceTier  // 传递服务等级
@@ -370,9 +366,10 @@ export async function handlePlanAction(
   panel: vscode.WebviewPanel,
   action: string,
   planTitle: string,
-  extensionPath: string
+  extensionPath: string,
+  serviceTier?: ServiceTier
 ): Promise<void> {
-  console.log("[handlePlanAction] action:", action, "planTitle:", planTitle);
+  console.log("[handlePlanAction] action:", action, "planTitle:", planTitle, "serviceTier:", serviceTier);
 
   switch (action) {
     case "confirm":
@@ -386,7 +383,8 @@ export async function handlePlanAction(
         panel,
         `请按照刚才的计划执行：${planTitle}`,
         extensionPath,
-        "agent"
+        "agent",
+        serviceTier
       );
       break;
 
@@ -402,7 +400,8 @@ export async function handlePlanAction(
           panel,
           `请根据以下建议修改计划：${modification}`,
           extensionPath,
-          "plan"
+          "plan",
+          serviceTier
         );
       }
       break;

src/views/ICViewProvider.ts

@@ -1,5 +1,6 @@
 import * as vscode from "vscode";
 import { getWebviewContent } from "./webviewContent";
+import { isTokenExpired } from "../utils/jwtUtils";
 import {
   handleUserMessage,
   insertCodeToEditor,
@@ -127,10 +128,34 @@ export function showICHelperPanel(context: vscode.ExtensionContext) {
  * 侧边栏视图提供者
  */
 export class ICViewProvider implements vscode.WebviewViewProvider {
+  private _view?: vscode.WebviewView;
+
   constructor(
     private readonly extensionUri: vscode.Uri,
     private readonly context: vscode.ExtensionContext
-  ) {}
+  ) {
+    // 监听认证状态变化
+    this.context.subscriptions.push(
+      vscode.authentication.onDidChangeSessions((e) => {
+        if (e.provider.id === "iccoder") {
+          this.refreshLoginStatus();
+        }
+      })
+    );
+  }
+
+  /**
+   * 刷新登录状态并更新视图
+   */
+  private async refreshLoginStatus(): Promise<void> {
+    if (this._view) {
+      const isLoggedIn = await this.checkLoginStatus();
+      this._view.webview.html = this.getWebviewContent(
+        this._view.webview,
+        isLoggedIn
+      );
+    }
+  }
 
   /**
    * 检查登录状态（使用 Authentication API）
@@ -138,14 +163,29 @@ export class ICViewProvider implements vscode.WebviewViewProvider {
   private async checkLoginStatus(): Promise<boolean> {
     try {
       const session = await vscode.authentication.getSession("iccoder", [], { createIfNone: false });
-      return !!session;
+      console.log("[ICViewProvider] 检查登录状态, session:", session ? "存在" : "不存在");
+      if (!session) {
+        return false;
+      }
+      // 检查 token 是否过期
+      const expired = isTokenExpired(session.accessToken);
+      console.log("[ICViewProvider] token 过期检查结果:", expired);
+      // 只有明确过期才认为未登录，无法判断时认为已登录
+      if (expired === true) {
+        console.log("[ICViewProvider] Token 已过期");
+        return false;
+      }
+      return true;
     } catch (error) {
-      console.log("检查登录状态失败:", error);
+      console.log("[ICViewProvider] 检查登录状态失败:", error);
       return false;
     }
   }
 
   resolveWebviewView(webviewView: vscode.WebviewView) {
+    // 保存引用以便后续刷新
+    this._view = webviewView;
+
     webviewView.webview.options = {
       enableScripts: true,
       localResourceRoots: [vscode.Uri.joinPath(this.extensionUri, "media")],

src/views/conversationHistoryBar.ts

@@ -303,6 +303,7 @@ export function getConversationHistoryBarScript(): string {
     let totalHistory = 0;
     let hasMoreHistory = false;
     let isLoadingHistory = false;
+    let currentLoadRequestId = 0;  // 请求 ID，用于防止并发加载
     const HISTORY_PAGE_SIZE = 10;
     const MAX_HISTORY_ITEMS = 100;
 
@@ -346,11 +347,15 @@ export function getConversationHistoryBarScript(): string {
         return;
       }
 
+      // 生成新的请求 ID，用于防止并发加载
+      const requestId = ++currentLoadRequestId;
+
       isLoadingHistory = true;
       vscode.postMessage({
         command: 'loadConversationHistory',
         offset: currentOffset,
-        limit: HISTORY_PAGE_SIZE
+        limit: HISTORY_PAGE_SIZE,
+        requestId: requestId
       });
     }
 
@@ -362,11 +367,19 @@ export function getConversationHistoryBarScript(): string {
         return;
       }
 
-      // 追加新数据
+      // 追加新数据（去重）
-      conversationHistory = conversationHistory.concat(data.items);
+      const existingIds = new Set(conversationHistory.map(item => item.id));
+      const newItems = [];
+      for (const item of data.items) {
+        if (!existingIds.has(item.id)) {
+          existingIds.add(item.id);
+          newItems.push(item);
+        }
+      }
+      conversationHistory = conversationHistory.concat(newItems);
       totalHistory = data.total;
       hasMoreHistory = data.hasMore;
-      currentOffset += data.items.length;
+      currentOffset = conversationHistory.length;
 
       const historyList = document.getElementById('historyList');
       if (!historyList) {
@@ -454,9 +467,10 @@ export function getConversationHistoryBarScript(): string {
       });
     }
 
-    // 监听下拉菜单滚动事件
+    // 监听下拉菜单滚动事件（防止重复注册）
     const historyDropdownMenu = document.getElementById('historyDropdownMenu');
-    if (historyDropdownMenu) {
+    if (historyDropdownMenu && !historyDropdownMenu._scrollListenerAdded) {
+      historyDropdownMenu._scrollListenerAdded = true;
       historyDropdownMenu.addEventListener('scroll', () => {
         const menu = historyDropdownMenu;
         const scrollTop = menu.scrollTop;

src/views/messageArea.ts

@@ -675,6 +675,29 @@ export function getMessageAreaScript(): string {
 
       ${getPlanCardScript()}
 
+      // 解析多 VCD 文件路径
+      function parseMultiVcdPaths(toolResult) {
+        if (!toolResult) return [];
+        const result = String(toolResult);
+
+        // 匹配 "- moduleName: path" 格式
+        const vcdListMatch = result.match(/VCD 文件列表:[\\s\\S]*?(?=\\n\\n|$)/);
+        if (!vcdListMatch) return [];
+
+        const paths = [];
+        const lineRegex = /- (\\w+): ([^\\n]+)/g;
+        let match;
+        while ((match = lineRegex.exec(vcdListMatch[0])) !== null) {
+          const name = match[1];
+          const pathOrError = match[2].trim();
+          // 跳过失败的条目
+          if (!pathOrError.startsWith('失败')) {
+            paths.push({ name: name + '.vcd', path: pathOrError });
+          }
+        }
+        return paths;
+      }
+
       // 获取工具图标
       function getToolIcon(toolName) {
         const iconMap = {
@@ -1057,19 +1080,30 @@ export function getMessageAreaScript(): string {
 
             // 如果是仿真工具且成功完成，尝试添加波形预览
             if (segment.toolName === 'simulation' && segment.toolStatus === 'success') {
-              // 优先使用显式提供的路径，否则从结果文本中解析
+              // 尝试解析多个 VCD 文件（多 VCD 模式）
-              let vcdPath = segment.vcdFilePath;
+              const vcdPaths = parseMultiVcdPaths(segment.toolResult);
-              if (!vcdPath && segment.toolResult) {
-                const match = String(segment.toolResult).match(/路径\s*:\s*(.+)/);
-                if (match && match[1]) {
-                  vcdPath = match[1].trim();
-                }
-              }
 
-              if (vcdPath) {
+              if (vcdPaths.length > 0) {
-                const fileName = segment.fileName || vcdPath.split(/[\\\\\/]/).pop() || 'waveform.vcd';
+                // 多 VCD 模式：为每个文件创建预览
-                const waveformPreview = createWaveformPreview(vcdPath, fileName);
+                vcdPaths.forEach(vcdInfo => {
-                segmentDiv.appendChild(waveformPreview);
+                  const waveformPreview = createWaveformPreview(vcdInfo.path, vcdInfo.name);
+                  segmentDiv.appendChild(waveformPreview);
+                });
+              } else {
+                // 单 VCD 模式（兼容旧逻辑）
+                let vcdPath = segment.vcdFilePath;
+                if (!vcdPath && segment.toolResult) {
+                  const match = String(segment.toolResult).match(/路径\s*:\s*(.+)/);
+                  if (match && match[1]) {
+                    vcdPath = match[1].trim();
+                  }
+                }
+
+                if (vcdPath) {
+                  const fileName = segment.fileName || vcdPath.split(/[\\\\\/]/).pop() || 'waveform.vcd';
+                  const waveformPreview = createWaveformPreview(vcdPath, fileName);
+                  segmentDiv.appendChild(waveformPreview);
+                }
               }
             }
 
@@ -1304,19 +1338,30 @@ export function getMessageAreaScript(): string {
 
             // 如果是仿真工具且成功完成，尝试添加波形预览
             if (segment.toolName === 'simulation' && segment.toolStatus === 'success') {
-              // 优先使用显式提供的路径，否则从结果文本中解析
+              // 尝试解析多个 VCD 文件（多 VCD 模式）
-              let vcdPath = segment.vcdFilePath;
+              const vcdPaths = parseMultiVcdPaths(segment.toolResult);
-              if (!vcdPath && segment.toolResult) {
-                const match = String(segment.toolResult).match(/路径\s*:\s*(.+)/);
-                if (match && match[1]) {
-                  vcdPath = match[1].trim();
-                }
-              }
 
-              if (vcdPath) {
+              if (vcdPaths.length > 0) {
-                const fileName = segment.fileName || vcdPath.split(/[\\\\\/]/).pop() || 'waveform.vcd';
+                // 多 VCD 模式：为每个文件创建预览
-                const waveformPreview = createWaveformPreview(vcdPath, fileName);
+                vcdPaths.forEach(vcdInfo => {
-                segmentDiv.appendChild(waveformPreview);
+                  const waveformPreview = createWaveformPreview(vcdInfo.path, vcdInfo.name);
+                  segmentDiv.appendChild(waveformPreview);
+                });
+              } else {
+                // 单 VCD 模式（兼容旧逻辑）
+                let vcdPath = segment.vcdFilePath;
+                if (!vcdPath && segment.toolResult) {
+                  const match = String(segment.toolResult).match(/路径\s*:\s*(.+)/);
+                  if (match && match[1]) {
+                    vcdPath = match[1].trim();
+                  }
+                }
+
+                if (vcdPath) {
+                  const fileName = segment.fileName || vcdPath.split(/[\\\\\/]/).pop() || 'waveform.vcd';
+                  const waveformPreview = createWaveformPreview(vcdPath, fileName);
+                  segmentDiv.appendChild(waveformPreview);
+                }
               }
             }
 

src/views/planCard.ts

@@ -4,6 +4,7 @@
  * 功能说明:
  * - 显示执行计划的卡片界面
  * - 包含计划标题、摘要和步骤列表
+ * - 摘要支持 Markdown 格式渲染
  * - 提供确认执行、修改计划、取消等操作按钮
  */
 
@@ -43,11 +44,62 @@ export function getPlanCardStyles(): string {
       padding: 16px;
     }
     .plan-summary {
-      color: var(--vscode-descriptionForeground);
+      color: var(--vscode-foreground);
       margin-bottom: 12px;
       font-size: 13px;
-      line-height: 1.5;
+      line-height: 1.6;
     }
+    /* Markdown 渲染样式 */
+    .plan-summary h1, .plan-summary h2, .plan-summary h3, .plan-summary h4 {
+      margin: 16px 0 8px 0;
+      font-weight: 600;
+      color: var(--vscode-foreground);
+    }
+    .plan-summary h1 { font-size: 18px; border-bottom: 1px solid var(--vscode-input-border); padding-bottom: 6px; }
+    .plan-summary h2 { font-size: 16px; }
+    .plan-summary h3 { font-size: 14px; }
+    .plan-summary h4 { font-size: 13px; }
+    .plan-summary p { margin: 8px 0; }
+    .plan-summary ul, .plan-summary ol {
+      margin: 8px 0;
+      padding-left: 24px;
+    }
+    .plan-summary li { margin: 4px 0; }
+    .plan-summary code {
+      background: var(--vscode-textCodeBlock-background);
+      padding: 2px 6px;
+      border-radius: 3px;
+      font-family: var(--vscode-editor-font-family);
+      font-size: 12px;
+    }
+    .plan-summary pre {
+      background: var(--vscode-textCodeBlock-background);
+      padding: 12px;
+      border-radius: 4px;
+      overflow-x: auto;
+      margin: 8px 0;
+    }
+    .plan-summary pre code {
+      background: none;
+      padding: 0;
+    }
+    .plan-summary table {
+      border-collapse: collapse;
+      width: 100%;
+      margin: 8px 0;
+      font-size: 12px;
+    }
+    .plan-summary th, .plan-summary td {
+      border: 1px solid var(--vscode-input-border);
+      padding: 6px 10px;
+      text-align: left;
+    }
+    .plan-summary th {
+      background: var(--vscode-sideBar-background);
+      font-weight: 600;
+    }
+    .plan-summary strong { font-weight: 600; }
+    .plan-summary em { font-style: italic; }
     .plan-steps {
       font-size: 13px;
     }
@@ -58,6 +110,15 @@ export function getPlanCardStyles(): string {
       border-radius: 4px;
       line-height: 1.5;
     }
+    .plan-step strong {
+      color: var(--vscode-textLink-foreground);
+    }
+    .step-details {
+      margin-top: 4px;
+      font-size: 12px;
+      color: var(--vscode-descriptionForeground);
+      line-height: 1.4;
+    }
     .plan-step:last-child {
       margin-bottom: 0;
     }
@@ -89,24 +150,50 @@ export function getPlanCardStyles(): string {
     .plan-actions {
       display: flex;
       flex-direction: column;
-      gap: 10px;
+      gap: 12px;
       padding: 14px 16px;
       border-top: 1px solid var(--vscode-input-border);
       background: var(--vscode-sideBar-background);
     }
-    .plan-actions .question-options {
+    .plan-input-row {
       display: flex;
-      flex-wrap: wrap;
       gap: 8px;
+      width: 100%;
+    }
+    .plan-input {
+      flex: 1;
+      padding: 10px 12px;
+      background: var(--vscode-input-background);
+      color: var(--vscode-input-foreground);
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 4px;
+      font-size: 13px;
+      box-sizing: border-box;
+    }
+    .plan-input:focus {
+      outline: none;
+      border-color: var(--vscode-focusBorder);
+    }
+    .plan-btn-row {
+      display: flex;
+      gap: 10px;
     }
     .plan-btn {
-      padding: 8px 18px;
+      padding: 8px 20px;
       border-radius: 4px;
       border: none;
       cursor: pointer;
-      font-size: 12px;
+      font-size: 13px;
       font-weight: 500;
     }
+    .plan-btn-submit {
+      background: var(--vscode-input-background);
+      color: var(--vscode-foreground);
+      border: 1px solid var(--vscode-input-border);
+    }
+    .plan-btn-submit:hover {
+      background: var(--vscode-list-hoverBackground);
+    }
     .plan-btn-confirm {
       background: var(--vscode-button-background);
       color: var(--vscode-button-foreground);
@@ -114,41 +201,188 @@ export function getPlanCardStyles(): string {
     .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;
+    }
+    .plan-btn-cancel:hover {
+      background: var(--vscode-list-hoverBackground);
+    }
+    .plan-answered {
+      padding: 12px 16px;
+      border-top: 1px solid var(--vscode-input-border);
+      background: var(--vscode-sideBar-background);
       font-size: 13px;
     }
-    .plan-actions .custom-submit {
+    .answered-label {
-      padding: 8px 18px;
+      color: var(--vscode-descriptionForeground);
-      background: var(--vscode-button-background);
+    }
-      color: var(--vscode-button-foreground);
+    .answered-value {
-      border: none;
+      color: var(--vscode-textLink-foreground);
-      border-radius: 4px;
-      cursor: pointer;
-      font-size: 12px;
       font-weight: 500;
     }
-    .plan-actions .custom-submit:hover {
+
-      background: var(--vscode-button-hoverBackground);
+    /* 阶段进度条样式 */
+    .phase-progress {
+      display: flex;
+      align-items: center;
+      padding: 12px 16px;
+      background: var(--vscode-sideBar-background);
+      border-bottom: 1px solid var(--vscode-input-border);
+    }
+    .phase-item {
+      display: flex;
+      align-items: center;
+      gap: 6px;
+      font-size: 12px;
+      color: var(--vscode-descriptionForeground);
+    }
+    .phase-item.current {
+      color: var(--vscode-textLink-foreground);
+      font-weight: 600;
+    }
+    .phase-item.completed {
+      color: #4caf50;
+    }
+    .phase-item.skipped {
+      color: var(--vscode-descriptionForeground);
+      opacity: 0.6;
+    }
+    .phase-dot {
+      width: 10px;
+      height: 10px;
+      border-radius: 50%;
+      background: var(--vscode-input-border);
+      flex-shrink: 0;
+    }
+    .phase-dot.current {
+      background: var(--vscode-textLink-foreground);
+      box-shadow: 0 0 0 3px rgba(0, 122, 204, 0.2);
+    }
+    .phase-dot.completed {
+      background: #4caf50;
+    }
+    .phase-dot.skipped {
+      background: var(--vscode-descriptionForeground);
+      opacity: 0.5;
+    }
+    .phase-line {
+      flex: 1;
+      height: 2px;
+      background: var(--vscode-input-border);
+      margin: 0 8px;
+    }
+    .phase-line.completed {
+      background: #4caf50;
+    }
+
+    /* 阶段列表样式 */
+    .plan-phases {
+      font-size: 13px;
+    }
+    .plan-phase {
+      margin-bottom: 12px;
+      border: 1px solid var(--vscode-input-border);
+      border-radius: 6px;
+      overflow: hidden;
+    }
+    .plan-phase:last-child {
+      margin-bottom: 0;
+    }
+    .phase-header {
+      display: flex;
+      align-items: center;
+      gap: 8px;
+      padding: 10px 12px;
+      background: var(--vscode-list-hoverBackground);
+      cursor: pointer;
+      user-select: none;
+    }
+    .phase-header:hover {
+      background: var(--vscode-list-activeSelectionBackground);
+    }
+    .phase-toggle {
+      font-size: 10px;
+      color: var(--vscode-descriptionForeground);
+      transition: transform 0.2s;
+    }
+    .phase-toggle.expanded {
+      transform: rotate(90deg);
+    }
+    .phase-name {
+      flex: 1;
+      font-weight: 500;
+    }
+    .phase-status {
+      font-size: 11px;
+      padding: 2px 8px;
+      border-radius: 10px;
+      background: var(--vscode-badge-background);
+      color: var(--vscode-badge-foreground);
+    }
+    .phase-status.current {
+      background: var(--vscode-textLink-foreground);
+      color: white;
+    }
+    .phase-status.skipped {
+      background: var(--vscode-descriptionForeground);
+      opacity: 0.6;
+    }
+    .phase-status.completed {
+      background: #4caf50;
+      color: white;
+    }
+    .phase-content {
+      padding: 0 12px;
+      max-height: 0;
+      overflow: hidden;
+      transition: max-height 0.3s ease, padding 0.3s ease;
+    }
+    .phase-content.expanded {
+      padding: 12px;
+      max-height: 500px;
+    }
+    .phase-reason {
+      font-size: 12px;
+      color: var(--vscode-descriptionForeground);
+      font-style: italic;
+      margin-bottom: 8px;
+    }
+    .phase-steps {
+      margin: 0;
+      padding: 0;
+      list-style: none;
+    }
+    .phase-step-item {
+      display: flex;
+      align-items: flex-start;
+      gap: 8px;
+      padding: 6px 0;
+      border-bottom: 1px solid var(--vscode-input-border);
+    }
+    .phase-step-item:last-child {
+      border-bottom: none;
+    }
+    .phase-step-checkbox {
+      width: 14px;
+      height: 14px;
+      border: 2px solid var(--vscode-textLink-foreground);
+      border-radius: 3px;
+      flex-shrink: 0;
+      margin-top: 2px;
+    }
+    .phase-step-text {
+      flex: 1;
+    }
+    .phase-step-name {
+      font-weight: 500;
+      color: var(--vscode-foreground);
+    }
+    .phase-step-desc {
+      font-size: 12px;
+      color: var(--vscode-descriptionForeground);
+      margin-top: 2px;
     }
   `;
 }
@@ -158,6 +392,200 @@ export function getPlanCardStyles(): string {
  */
 export function getPlanCardScript(): string {
   return `
+    // 简单的 Markdown 渲染函数
+    function renderPlanMarkdown(text) {
+      if (!text) return '';
+
+      let html = text;
+
+      // 转义 HTML 特殊字符（保留换行）
+      html = html.replace(/&/g, '&')
+                 .replace(/</g, '&lt;')
+                 .replace(/>/g, '&gt;');
+
+      // 代码块 (\`\`\`code\`\`\`)
+      html = html.replace(/\\x60\\x60\\x60([\\s\\S]*?)\\x60\\x60\\x60/g, '<pre><code>$1</code></pre>');
+
+      // 行内代码 (\`code\`)
+      html = html.replace(/\\x60([^\\x60]+)\\x60/g, '<code>$1</code>');
+
+      // 表格处理
+      html = html.replace(/^\\|(.+)\\|\\s*\\n\\|[-:\\s|]+\\|\\s*\\n((?:\\|.+\\|\\s*\\n?)+)/gm, function(match, header, body) {
+        const headers = header.split('|').map(h => h.trim()).filter(h => h);
+        const rows = body.trim().split('\\n').map(row =>
+          row.split('|').map(cell => cell.trim()).filter(cell => cell)
+        );
+
+        let table = '<table><thead><tr>';
+        headers.forEach(h => table += '<th>' + h + '</th>');
+        table += '</tr></thead><tbody>';
+        rows.forEach(row => {
+          table += '<tr>';
+          row.forEach(cell => table += '<td>' + cell + '</td>');
+          table += '</tr>';
+        });
+        table += '</tbody></table>';
+        return table;
+      });
+
+      // 标题
+      html = html.replace(/^#### (.+)$/gm, '<h4>$1</h4>');
+      html = html.replace(/^### (.+)$/gm, '<h3>$1</h3>');
+      html = html.replace(/^## (.+)$/gm, '<h2>$1</h2>');
+      html = html.replace(/^# (.+)$/gm, '<h1>$1</h1>');
+
+      // 粗体和斜体
+      html = html.replace(/\\*\\*(.+?)\\*\\*/g, '<strong>$1</strong>');
+      html = html.replace(/\\*(.+?)\\*/g, '<em>$1</em>');
+
+      // 无序列表
+      html = html.replace(/^[\\s]*[-*] (.+)$/gm, '<li>$1</li>');
+      html = html.replace(/(<li>.*<\\/li>\\n?)+/g, '<ul>$&</ul>');
+
+      // 有序列表
+      html = html.replace(/^[\\s]*\\d+\\. (.+)$/gm, '<li>$1</li>');
+
+      // 段落（连续的非空行）
+      html = html.replace(/^(?!<[hupolt]|$)(.+)$/gm, '<p>$1</p>');
+
+      // 清理多余的空行
+      html = html.replace(/<p><\\/p>/g, '');
+      html = html.replace(/\\n{2,}/g, '\\n');
+
+      return html;
+    }
+
+    // 解析并渲染步骤列表
+    function renderPlanSteps(steps) {
+      if (!steps || steps.length === 0) return '';
+
+      // 尝试解析 JSON 格式的步骤
+      let parsedSteps = steps;
+
+      // 如果是单个字符串且看起来像 JSON 数组，尝试解析
+      if (steps.length === 1 && typeof steps[0] === 'string') {
+        const str = steps[0].trim();
+        if (str.startsWith('[') && str.endsWith(']')) {
+          try {
+            parsedSteps = JSON.parse(str);
+          } catch (e) {
+            // 解析失败，保持原样
+          }
+        }
+      }
+
+      return parsedSteps.map((step, i) => {
+        // 如果是对象，格式化显示
+        if (typeof step === 'object' && step !== null) {
+          const name = step.name || step.id || ('步骤 ' + (i + 1));
+          const desc = step.description || '';
+          const inputs = step.inputs || '';
+          const outputs = step.outputs || '';
+          const logic = step.logic || '';
+
+          let content = '<strong>' + name + '</strong>';
+          if (desc) content += '：' + desc;
+
+          let details = [];
+          if (inputs) details.push('输入: ' + inputs);
+          if (outputs) details.push('输出: ' + outputs);
+          if (logic) details.push('逻辑: ' + logic);
+
+          if (details.length > 0) {
+            content += '<div class="step-details">' + details.join(' | ') + '</div>';
+          }
+
+          return '<div class="plan-step"><span class="step-checkbox"></span>' + content + '</div>';
+        }
+
+        // 普通字符串
+        return '<div class="plan-step"><span class="step-checkbox"></span> ' + step + '</div>';
+      }).join('');
+    }
+
+    // 渲染阶段进度条
+    function renderPhaseProgress(phases) {
+      if (!phases || phases.length === 0) return '';
+
+      const phaseNames = { spec: 'Spec', design: 'Design', sim: 'Sim', done: 'Done' };
+      let html = '<div class="phase-progress">';
+
+      phases.forEach((phase, i) => {
+        const name = phaseNames[phase.id] || phase.name || phase.id;
+        const status = phase.status || 'pending';
+
+        html += \`<div class="phase-item \${status}">
+          <span class="phase-dot \${status}"></span>
+          <span>\${name}</span>
+        </div>\`;
+
+        // 添加连接线（最后一个不加）
+        if (i < phases.length - 1) {
+          const lineStatus = (status === 'completed' || status === 'skipped') ? 'completed' : '';
+          html += \`<div class="phase-line \${lineStatus}"></div>\`;
+        }
+      });
+
+      html += '</div>';
+      return html;
+    }
+
+    // 渲染阶段列表（两级结构）
+    function renderPlanPhases(phases) {
+      if (!phases || phases.length === 0) return '';
+
+      const statusLabels = {
+        skipped: '跳过',
+        completed: '已完成',
+        current: '当前',
+        pending: '待执行'
+      };
+
+      return phases.map((phase, i) => {
+        const status = phase.status || 'pending';
+        const statusLabel = statusLabels[status] || status;
+        const isExpanded = status === 'current';
+        const hasSteps = phase.steps && phase.steps.length > 0;
+        const hasReason = phase.reason && status === 'skipped';
+
+        let stepsHtml = '';
+        if (phase.steps && phase.steps.length > 0) {
+          stepsHtml = phase.steps.map(step => \`
+            <li class="phase-step-item">
+              <span class="phase-step-checkbox"></span>
+              <div class="phase-step-text">
+                <div class="phase-step-name">\${step.name || ''}</div>
+                \${step.description ? \`<div class="phase-step-desc">\${step.description}</div>\` : ''}
+              </div>
+            </li>
+          \`).join('');
+        }
+
+        return \`
+          <div class="plan-phase" data-phase-id="\${phase.id}">
+            <div class="phase-header" onclick="togglePhase(this)">
+              <span class="phase-toggle \${isExpanded ? 'expanded' : ''}">▶</span>
+              <span class="phase-name">\${phase.name || phase.id}</span>
+              <span class="phase-status \${status}">\${statusLabel}</span>
+            </div>
+            <div class="phase-content \${isExpanded ? 'expanded' : ''}">
+              \${hasReason ? \`<div class="phase-reason">\${phase.reason}</div>\` : ''}
+              \${hasSteps ? \`<ul class="phase-steps">\${stepsHtml}</ul>\` : ''}
+              \${!hasSteps && !hasReason ? '<div class="phase-reason">暂无步骤</div>' : ''}
+            </div>
+          </div>
+        \`;
+      }).join('');
+    }
+
+    // 切换阶段展开/折叠
+    function togglePhase(header) {
+      const toggle = header.querySelector('.phase-toggle');
+      const content = header.nextElementSibling;
+      toggle.classList.toggle('expanded');
+      content.classList.toggle('expanded');
+    }
+
     // 渲染计划卡片（在 updateSegmentsRealtime 中使用）
     function renderPlanCardInSegment(segment, segmentDiv, answeredQuestions) {
       segmentDiv.className += ' segment-plan';
@@ -170,16 +598,26 @@ export function getPlanCardScript(): string {
         segmentDiv.classList.add('answered');
       }
 
-      const stepsHtml = (segment.planSteps || []).map((step, i) =>
+      // 判断是否有 phases（新格式）还是 steps（旧格式）
-        \`<div class="plan-step"><span class="step-checkbox"></span> \${step}</div>\`
+      const hasPhases = segment.planPhases && segment.planPhases.length > 0;
-      ).join('');
 
-      // 选项按钮
+      // 渲染阶段进度条和阶段列表（新格式）
-      const options = ['确认执行', '修改计划', '取消'];
+      const progressHtml = hasPhases ? renderPhaseProgress(segment.planPhases) : '';
-      const optionsHtml = options.map(opt => {
+      const phasesHtml = hasPhases ? renderPlanPhases(segment.planPhases) : '';
-        const isSelected = isAnswered && opt === selectedAnswer;
+
-        return \`<button class="question-option\${isSelected ? ' selected' : ''}" data-option="\${opt}">\${opt}</button>\`;
+      // 兼容旧格式：渲染步骤列表
-      }).join('');
+      const stepsHtml = !hasPhases ? renderPlanSteps(segment.planSteps || []) : '';
+
+      // 渲染 Markdown 格式的摘要
+      const summaryHtml = renderPlanMarkdown(segment.planSummary || '');
+
+      // 已回答时显示用户的选择
+      const answeredHtml = isAnswered ? \`
+        <div class="plan-answered">
+          <span class="answered-label">已回复：</span>
+          <span class="answered-value">\${selectedAnswer}</span>
+        </div>
+      \` : '';
 
       segmentDiv.innerHTML = \`
         <div class="plan-card">
@@ -187,62 +625,77 @@ export function getPlanCardScript(): string {
             <span class="plan-icon">${plannerIconSvg}</span>
             <span class="plan-title">\${segment.planTitle || '执行计划'}</span>
           </div>
+          \${progressHtml}
           <div class="plan-body">
-            <div class="plan-summary">\${segment.planSummary || ''}</div>
+            <div class="plan-summary">\${summaryHtml}</div>
-            <div class="plan-steps">\${stepsHtml}</div>
+            \${hasPhases ? \`<div class="plan-phases">\${phasesHtml}</div>\` : \`<div class="plan-steps">\${stepsHtml}</div>\`}
           </div>
-          <div class="plan-actions">
+          <div class="plan-actions" data-ask-id="\${segment.askId}" style="display: \${isAnswered ? 'none' : 'flex'};">
-            <div class="question-options" data-ask-id="\${segment.askId}">\${optionsHtml}</div>
+            <div class="plan-input-row">
-            <div class="custom-input-container" style="display: \${isAnswered ? 'none' : 'flex'};">
+              <input type="text" class="plan-input" placeholder="输入修改建议..." />
-              <input type="text" class="custom-input" placeholder="输入修改建议..." />
+              <button class="plan-btn plan-btn-submit">提交修改</button>
-              <button class="custom-submit">提交</button>
+            </div>
+            <div class="plan-btn-row">
+              <button class="plan-btn plan-btn-confirm">确认执行</button>
+              <button class="plan-btn plan-btn-cancel">取消</button>
             </div>
           </div>
+          \${answeredHtml}
         </div>
       \`;
 
       // 只在未回答时添加事件监听
       if (!isAnswered) {
         setTimeout(() => {
-          const optionButtons = segmentDiv.querySelectorAll('.question-option');
+          const submitBtn = segmentDiv.querySelector('.plan-btn-submit');
-          optionButtons.forEach(btn => {
+          const confirmBtn = segmentDiv.querySelector('.plan-btn-confirm');
-            btn.addEventListener('click', function() {
+          const cancelBtn = segmentDiv.querySelector('.plan-btn-cancel');
-              const option = this.getAttribute('data-option');
+          const planInput = segmentDiv.querySelector('.plan-input');
-              // 发送答案到后端
-              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 && planInput) {
-          if (submitBtn && customInput) {
             submitBtn.addEventListener('click', function() {
-              const customValue = customInput.value.trim();
+              const inputValue = planInput.value.trim();
-              if (customValue) {
+              if (inputValue) {
-                handleQuestionAnswerInSegment(segment.askId, customValue, segmentDiv);
+                handleQuestionAnswerInSegment(segment.askId, inputValue, segmentDiv);
               }
             });
 
-            customInput.addEventListener('keypress', function(e) {
+            // 回车键提交修改
+            planInput.addEventListener('keypress', function(e) {
               if (e.key === 'Enter') {
-                const customValue = customInput.value.trim();
+                const inputValue = planInput.value.trim();
-                if (customValue) {
+                if (inputValue) {
-                  handleQuestionAnswerInSegment(segment.askId, customValue, segmentDiv);
+                  handleQuestionAnswerInSegment(segment.askId, inputValue, segmentDiv);
                 }
               }
             });
           }
+
+          // 确认执行按钮
+          if (confirmBtn) {
+            confirmBtn.addEventListener('click', function() {
+              handleQuestionAnswerInSegment(segment.askId, '确认执行', segmentDiv);
+            });
+          }
+
+          // 取消按钮 - 直接中止对话，不发送给智能体
+          if (cancelBtn) {
+            cancelBtn.addEventListener('click', function() {
+              // 标记问题已回答
+              answeredQuestions.set(segment.askId, '取消');
+              segmentDiv.classList.add('answered');
+
+              // 隐藏操作按钮
+              const actionsDiv = segmentDiv.querySelector('.plan-actions');
+              if (actionsDiv) {
+                actionsDiv.style.display = 'none';
+              }
+
+              // 发送中止对话命令
+              vscode.postMessage({ command: 'abortDialog' });
+            });
+          }
         }, 0);
       }
     }
@@ -250,9 +703,19 @@ export function getPlanCardScript(): string {
     // 渲染计划卡片（在 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>\`
+      // 判断是否有 phases（新格式）还是 steps（旧格式）
-      ).join('');
+      const hasPhases = segment.planPhases && segment.planPhases.length > 0;
+
+      // 渲染阶段进度条和阶段列表（新格式）
+      const progressHtml = hasPhases ? renderPhaseProgress(segment.planPhases) : '';
+      const phasesHtml = hasPhases ? renderPlanPhases(segment.planPhases) : '';
+
+      // 兼容旧格式：渲染步骤列表
+      const stepsHtml = !hasPhases ? renderPlanSteps(segment.planSteps || []) : '';
+
+      // 渲染 Markdown 格式的摘要
+      const summaryHtml = renderPlanMarkdown(segment.planSummary || '');
 
       segmentDiv.innerHTML = \`
         <div class="plan-card">
@@ -260,33 +723,70 @@ export function getPlanCardScript(): string {
             <span class="plan-icon">📋</span>
             <span class="plan-title">\${segment.planTitle || '执行计划'}</span>
           </div>
+          \${progressHtml}
           <div class="plan-body">
-            <div class="plan-summary">\${segment.planSummary || ''}</div>
+            <div class="plan-summary">\${summaryHtml}</div>
-            <div class="plan-steps">\${stepsHtml}</div>
+            \${hasPhases ? \`<div class="plan-phases">\${phasesHtml}</div>\` : \`<div class="plan-steps">\${stepsHtml}</div>\`}
           </div>
-          <div class="plan-actions">
+          <div class="plan-actions" data-ask-id="\${segment.askId}">
-            <button class="plan-btn plan-btn-confirm" data-action="confirm">确认执行</button>
+            <div class="plan-input-row">
-            <button class="plan-btn plan-btn-modify" data-action="modify">修改计划</button>
+              <input type="text" class="plan-input" placeholder="输入修改建议..." />
-            <button class="plan-btn plan-btn-cancel" data-action="cancel">取消</button>
+              <button class="plan-btn plan-btn-submit">提交修改</button>
+            </div>
+            <div class="plan-btn-row">
+              <button class="plan-btn plan-btn-confirm">确认执行</button>
+              <button class="plan-btn plan-btn-cancel">取消</button>
+            </div>
           </div>
         </div>
       \`;
 
-      // 绑定按钮事件
+      // 绑定按钮事件（静态渲染时也需要能响应）
       setTimeout(() => {
-        const planCard = segmentDiv.querySelector('.plan-card');
+        const submitBtn = segmentDiv.querySelector('.plan-btn-submit');
-        if (planCard) {
+        const confirmBtn = segmentDiv.querySelector('.plan-btn-confirm');
-          planCard.querySelectorAll('.plan-btn').forEach(btn => {
+        const cancelBtn = segmentDiv.querySelector('.plan-btn-cancel');
-            btn.addEventListener('click', (e) => {
+        const planInput = segmentDiv.querySelector('.plan-input');
-              const action = e.currentTarget?.dataset?.action;
+
+        // 提交修改按钮
+        if (submitBtn && planInput) {
+          submitBtn.addEventListener('click', function() {
+            const inputValue = planInput.value.trim();
+            if (inputValue) {
               vscode.postMessage({
-                command: 'planAction',
+                command: 'submitAnswer',
-                action: action,
+                askId: segment.askId,
-                planTitle: segment.planTitle
+                selected: [inputValue],
+                customInput: inputValue
               });
+            }
+          });
+        }
+
+        // 确认执行按钮
+        if (confirmBtn) {
+          confirmBtn.addEventListener('click', function() {
+            vscode.postMessage({
+              command: 'submitAnswer',
+              askId: segment.askId,
+              selected: ['确认执行'],
+              customInput: '确认执行'
             });
           });
         }
+
+        // 取消按钮 - 直接中止对话
+        if (cancelBtn) {
+          cancelBtn.addEventListener('click', function() {
+            // 隐藏操作按钮
+            const actionsDiv = segmentDiv.querySelector('.plan-actions');
+            if (actionsDiv) {
+              actionsDiv.style.display = 'none';
+            }
+            // 发送中止对话命令
+            vscode.postMessage({ command: 'abortDialog' });
+          });
+        }
       }, 0);
     }
   `;