Update optimization-progress.js

ui/optimization-progress.js

@@ -1,14 +1,12 @@
 import { extensionName } from '../utils/settings.js';
 
 let modalInstance = null;
-// 状态追踪对象，用于分别管理主模型(A)和并发模型(B)
 let trackState = {
     main: { step: 0, text: '准备就绪...', active: false, fillEl: null, textEl: null },
     concurrent: { step: 0, text: '等待启动...', active: false, fillEl: null, textEl: null }
 };
-const totalEstimatedSteps = 7; // 减少预估步骤数，让进度条跑得更快
+const totalEstimatedSteps = 5;
 
-// 消息队列系统 - 双轨并行
 let messageQueues = {
     main: [],
     concurrent: []
@@ -198,7 +196,6 @@ export function showPlotOptimizationProgress(cancellationState) {
     
     modalInstance = document.getElementById('amily2-progress-bar-container');
     
-    // 初始化轨道元素引用
     trackState.main.fillEl = document.getElementById('amily2-fill-main');
     trackState.main.textEl = document.getElementById('amily2-text-main');
     trackState.main.step = 0;
@@ -207,11 +204,10 @@ export function showPlotOptimizationProgress(cancellationState) {
     trackState.concurrent.fillEl = document.getElementById('amily2-fill-concurrent');
     trackState.concurrent.textEl = document.getElementById('amily2-text-concurrent');
     trackState.concurrent.step = 0;
-    trackState.concurrent.active = false; // 默认不激活，直到收到相关消息
+    trackState.concurrent.active = false; 
 
     const cancelButton = document.getElementById('amily2-progress-cancel');
-    
+
-    // 重置消息队列
     messageQueues = {
         main: [],
         concurrent: []
@@ -221,7 +217,6 @@ export function showPlotOptimizationProgress(cancellationState) {
         concurrent: false
     };
 
-    // 触发入场动画
     requestAnimationFrame(() => {
         if (modalInstance) {
             modalInstance.classList.add('visible');
@@ -234,14 +229,12 @@ export function showPlotOptimizationProgress(cancellationState) {
             if (trackState.main.textEl) trackState.main.textEl.textContent = "正在中止任务...";
             if (trackState.main.fillEl) trackState.main.fillEl.style.backgroundColor = "#ff6b6b";
             toastr.info("记忆管理任务已请求中止。");
-            // 延迟关闭以显示中止状态
             setTimeout(hidePlotOptimizationProgress, 800);
         });
     }
 }
 
 export function updatePlotOptimizationProgress(message, isDone = false, isSkipped = false) {
-    // 如果是最后一步，强制清空所有队列并立即执行
     if (message.includes('记忆重构完成') || message.includes('所有任务已完成')) {
         messageQueues.main = [];
         messageQueues.concurrent = [];
@@ -250,14 +243,11 @@ export function updatePlotOptimizationProgress(message, isDone = false, isSkippe
         return;
     }
 
-    // 判断消息归属
     const isConcurrent = message.includes('(LLM-B)') || message.includes('(并发模型)');
     const queueType = isConcurrent ? 'concurrent' : 'main';
 
-    // 加入对应队列
     messageQueues[queueType].push({ message, isDone, isSkipped });
-    
+
-    // 触发对应队列的处理
     processQueue(queueType);
 }
 
@@ -269,22 +259,13 @@ async function processQueue(queueType) {
     while (messageQueues[queueType].length > 0) {
         const { message, isDone, isSkipped } = messageQueues[queueType].shift();
         
-        // 执行实际的 UI 更新
         performUpdate(message, isDone, isSkipped);
-        
-        // 如果是“开始”某个步骤（非完成/跳过），或者是重要的完成状态，我们给予展示时间
-        // 对于“请求 LLM”这种耗时操作，本身就会卡很久，所以不需要额外延迟，
-        // 但对于那些瞬间完成的步骤（如“构建提示词”），我们需要人为暂停一下。
-        
-        // 简单的策略：所有状态更新都至少展示 MIN_DISPLAY_TIME
-        // 除非是 LLM 请求开始，因为那个会自然等待
         const isLongRunningTaskStart = message.includes('请求') && !isDone && !isSkipped;
         
         if (!isLongRunningTaskStart) {
             await new Promise(resolve => setTimeout(resolve, MIN_DISPLAY_TIME));
         } else {
-            // 对于 LLM 请求开始，我们只给一个很短的缓冲，让用户看清文字即可，
+
-            // 剩下的时间由 LLM 的实际响应时间填充
             await new Promise(resolve => setTimeout(resolve, 500));
         }
     }
@@ -295,41 +276,43 @@ async function processQueue(queueType) {
 function performUpdate(message, isDone, isSkipped) {
     if (!modalInstance) return;
 
-    // 过滤掉一些不需要显示的辅助信息
     if (message === '初始化任务...' || message === '所有任务已完成') {
         if (trackState.main.textEl) trackState.main.textEl.textContent = message;
         return;
     }
 
-    // 判断是主模型还是并发模型的消息
     const isConcurrent = message.includes('(LLM-B)') || message.includes('(并发模型)');
     const track = isConcurrent ? trackState.concurrent : trackState.main;
     const trackId = isConcurrent ? 'amily2-track-concurrent' : 'amily2-track-main';
 
-    // 如果是并发模型消息，确保轨道可见
     if (isConcurrent && !track.active) {
         track.active = true;
         const trackEl = document.getElementById(trackId);
         if (trackEl) trackEl.style.display = 'block';
     }
-
-    // 清理消息中的标识符，让显示更干净
     const cleanMessage = message.replace(/\(LLM-[AB]\)|\(主模型\)|\(并发模型\)/g, '').trim();
 
     if (isDone || isSkipped) {
         track.step++;
-        // 计算进度：最大只能到 95%，最后一步直接跳满
         let percentage = Math.min((track.step / totalEstimatedSteps) * 100, 95);
-        
+
-        // 如果是最终完成消息，直接满格
         if (message.includes('记忆重构完成') || message.includes('所有任务已完成')) {
             percentage = 100;
-            // 同时让并发轨道也满格（如果激活的话）
             if (trackState.concurrent.active && trackState.concurrent.fillEl) {
                 trackState.concurrent.fillEl.style.width = '100%';
                 if (trackState.concurrent.textEl) trackState.concurrent.textEl.textContent = '同步完成 ✅';
             }
         }
+        
+        // 特殊处理：并发模型的最后一步
+        if (isConcurrent && (message.includes('深度逻辑推演') || message.includes('计算情感最优解'))) {
+             percentage = 100;
+        }
+        
+        // 特殊处理：主模型的最后一步（在记忆重构之前）
+        if (!isConcurrent && (message.includes('核心意识同步') || message.includes('等待灵魂共鸣'))) {
+             percentage = 100;
+        }
 
         if (track.fillEl) {
             track.fillEl.style.width = `${percentage}%`;