@myassis/gateway 1.0.78 → 1.0.82

package/dist/config/index.js

@@ -90,7 +90,11 @@ exports.appConfig = {
     /** 超出 toolPairKeep 的旧工具调用内容截断长度 */
     oldToolContentLimit: parseInt(process.env.OLD_TOOL_CONTENT_LIMIT || '500', 10),
     /** 单次请求内最大工具调用轮数 */
-    maxToolRounds: parseInt(process.env.MAX_TOOL_ROUNDS || '100', 10),
+    maxToolRounds: parseInt(process.env.MAX_TOOL_ROUNDS || '200', 10),
+    /** 是否启用后台预压缩：回复结束后预先生成摘要，降低下一轮首字延迟 */
+    enablePrecompression: process.env.ENABLE_PRECOMPRESSION !== 'false',
+    /** 回复结束后延迟多久启动预压缩（毫秒），留出时间给用户连续追问 */
+    precompressionDelay: parseInt(process.env.PRECOMPRESSION_DELAY || '3000', 10),
     /** 触发上下文压缩的字符阈值 */
     summaryTriggerChars: parseInt(process.env.SUMMARY_TRIGGER_CHARS || '60000', 10),
     appName: '我的助手'

package/dist/services/agent/AgentManager.js

@@ -254,7 +254,8 @@ class AgentManager {
             createdAt: s.createdAt,
             updatedAt: s.updatedAt,
             messageQueue: s.messageQueue,
-            messageQueueAutoExecute: s.messageQueueAutoExecute
+            messageQueueAutoExecute: s.messageQueueAutoExecute,
+            plan: s.plan
         }));
     }
     /**

package/dist/services/memory/ContextBuilder.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.nextTrimLevel = exports.buildContext = exports.estimateTokens = exports.estimateChars = exports.TrimLevel = void 0;
 const shared_1 = require("@myassis/shared");
 const index_js_1 = require("../../config/index.js");
+const ToolLedger_js_1 = require("./ToolLedger.js");
 const logger = (0, shared_1.getLogger)('ContextBuilder');
 /**
  * 上下文构造与分级裁剪
@@ -14,17 +15,35 @@ const logger = (0, shared_1.getLogger)('ContextBuilder');
  */
 /** 中英混合场景下的粗略 token 估算系数 */
 const CHARS_PER_TOKEN = 1.6;
-/** 裁剪级别，逐级加重 */
+/** 骨架化后单条工具结果保留的长度 */
+const SKELETON_OUTPUT_LIMIT = 120;
+/**
+ * 裁剪级别，逐级加重。
+ *
+ * 设计原则：**任何级别都不会删除工具调用记录**。
+ * 一旦删除，模型就看不到自己已经做过什么，会重复调用同一个工具
+ * （重复读文件、重复写入、重复执行命令），比截断内容的代价大得多。
+ * 因此加重裁剪只压缩「负载」（输出正文、参数值、附件），
+ * 始终保留「调用事实」（工具名 + 关键参数 + 成功/失败）。
+ */
 var TrimLevel;
 (function (TrimLevel) {
     /** 不裁剪 */
     TrimLevel[TrimLevel["None"] = 0] = "None";
-    /** 截断超出 toolPairKeep 的旧工具输出与参数 */
+    /** 截断超出 toolPairKeep 轮的旧工具输出 */
     TrimLevel[TrimLevel["OldToolPayload"] = 1] = "OldToolPayload";
-    /** 进一步压缩保留轮数，并降级旧附件为占位符 */
+    /** 收紧保留轮数、截断参数值、降级旧附件为占位符 */
     TrimLevel[TrimLevel["Aggressive"] = 2] = "Aggressive";
-    /** 丢弃最早的完整工具调用对，只留最近 minToolPairKeep 轮 */
-    TrimLevel[TrimLevel["DropOldPairs"] = 3] = "DropOldPairs";
+    /** 旧工具调用退化为骨架：仅保留工具名、关键参数与结果摘要 */
+    TrimLevel[TrimLevel["SkeletonOldCalls"] = 3] = "SkeletonOldCalls";
+    /**
+     * 最后手段：把旧工具调用折叠进一份「已完成操作」账本。
+     *
+     * 消息条目本身被移除，但调用事实以清单形式并入首条 system 消息，
+     * 模型依然知道哪些操作已经做过 —— 这是「不丢事实」与「控制体积」的折中，
+     * 仅在骨架化后仍超预算（数百轮调用）时启用。
+     */
+    TrimLevel[TrimLevel["FoldToLedger"] = 4] = "FoldToLedger";
 })(TrimLevel || (exports.TrimLevel = TrimLevel = {}));
 /** 估算单条消息的字符数（含附件与工具参数） */
 function messageChars(message) {
@@ -164,6 +183,138 @@ function clipPair(messages, pair, limit) {
         messages[i].content = clip(messages[i].content, limit);
     }
 }
+/** 从工具参数中提取用于标识「这次调用做了什么」的关键字段 */
+const IDENTITY_KEYS = [
+    'path', 'file', 'filePath', 'filename', 'dir', 'directory',
+    'command', 'cmd', 'query', 'pattern', 'url', 'name', 'key', 'id',
+    'action', 'method', 'sessionId', 'target',
+];
+/** 单个关键参数值的最大长度 */
+const IDENTITY_VALUE_LIMIT = 200;
+/**
+ * 将工具参数压成「身份摘要」：只留能标识调用对象的关键字段。
+ *
+ * 例如 write_file 的 4000 字 content 被丢掉，但 path 保留，
+ * 模型据此知道「src/a.ts 已经写过了」，不会重复写入。
+ */
+function skeletonArguments(args) {
+    let parsed;
+    if (typeof args === 'string') {
+        try {
+            parsed = JSON.parse(args);
+        }
+        catch {
+            return JSON.stringify({ _omitted: true });
+        }
+    }
+    else if (args && typeof args === 'object') {
+        parsed = args;
+    }
+    else {
+        return '{}';
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        return JSON.stringify({ _omitted: true });
+    }
+    const out = {};
+    for (const key of Object.keys(parsed)) {
+        if (!IDENTITY_KEYS.includes(key))
+            continue;
+        const value = parsed[key];
+        if (value == null)
+            continue;
+        if (typeof value === 'object')
+            continue;
+        const text = String(value);
+        out[key] = text.length > IDENTITY_VALUE_LIMIT
+            ? text.slice(0, IDENTITY_VALUE_LIMIT) + '...'
+            : text;
+    }
+    // 标记参数已省略，避免模型误以为这是完整参数而照抄
+    out._omitted = true;
+    return JSON.stringify(out);
+}
+/** 从工具结果中提炼一行摘要，保留成功/失败信号 */
+function skeletonOutput(content) {
+    const text = typeof content === 'string' ? content : JSON.stringify(content ?? '');
+    if (!text)
+        return '(已执行，结果略)';
+    let success = null;
+    let body = text;
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed && typeof parsed === 'object') {
+            if (typeof parsed.success === 'boolean')
+                success = parsed.success;
+            if (parsed.output != null) {
+                body = typeof parsed.output === 'string' ? parsed.output : JSON.stringify(parsed.output);
+            }
+        }
+    }
+    catch {
+        // 非 JSON 结果，直接用原文
+    }
+    const head = body.replace(/\s+/g, ' ').slice(0, SKELETON_OUTPUT_LIMIT);
+    const flag = success === null ? '' : success ? '[成功] ' : '[失败] ';
+    return `${flag}${head}${body.length > SKELETON_OUTPUT_LIMIT ? '…' : ''}（完整结果已省略，勿重复调用）`;
+}
+/**
+ * 将一个工具调用对退化为骨架。
+ *
+ * 保留 assistant.tool_calls 与配对的 tool 消息（协议要求且模型需要看到调用事实），
+ * 只把参数压成身份摘要、把输出压成一行结论。
+ */
+function skeletonizePair(messages, pair) {
+    const head = messages[pair.start];
+    head.content = clip(head.content, SKELETON_OUTPUT_LIMIT);
+    // 旧轮次的思维链对当前决策价值最低，直接丢弃
+    delete head.reasoning_content;
+    if (Array.isArray(head.tool_calls)) {
+        for (const tc of head.tool_calls) {
+            tc.input = skeletonArguments(tc.input);
+            if (tc.function) {
+                tc.function.arguments = skeletonArguments(tc.function.arguments);
+            }
+        }
+    }
+    for (let i = pair.start + 1; i < pair.end; i++) {
+        messages[i].content = skeletonOutput(messages[i].content);
+    }
+}
+/**
+ * 把最早的工具调用对折叠进账本。
+ *
+ * 与已废弃的「直接丢弃」不同：调用事实不会消失，而是转成
+ * 首条 system 消息中的「已完成操作」清单。
+ */
+function foldPairsToLedger(messages, pairs, foldCount, protectFrom) {
+    if (foldCount <= 0)
+        return messages;
+    const foldIndexes = new Set();
+    const folded = [];
+    for (let i = 0; i < foldCount; i++) {
+        for (let j = pairs[i].start; j < pairs[i].end; j++) {
+            foldIndexes.add(j);
+            folded.push(messages[j]);
+        }
+    }
+    const ledger = (0, ToolLedger_js_1.renderRequestLedger)(folded);
+    const kept = messages.filter((_, index) => !foldIndexes.has(index));
+    if (!ledger)
+        return kept;
+    // 并入首条 system 消息：部分厂商只允许 system 位于首位
+    if (kept[0]?.role === 'system' && typeof kept[0].content === 'string') {
+        kept[0] = { ...kept[0], content: `${kept[0].content}\n\n${ledger}` };
+    }
+    else {
+        kept.splice(Math.min(protectFrom, kept.length), 0, {
+            role: 'assistant',
+            content: ledger,
+            attachments: [],
+        });
+    }
+    return kept;
+}
 /** 将较早的图片 / 音频附件降级为文本占位符，避免 base64 永久占用上下文 */
 function degradeAttachments(messages, keepLastN) {
     const withAttachments = [];
@@ -202,39 +353,31 @@ function buildContext(messages, protectFrom, maxChars = index_js_1.appConfig.con
         const keep = target >= TrimLevel.Aggressive
             ? index_js_1.appConfig.minToolPairKeep
             : index_js_1.appConfig.toolPairKeep;
-        // 1) 截断超出 keep 轮的旧工具调用负载
+        // 1) 最重级别：把最早的工具调用退化为骨架（保留调用事实，丢弃负载）
+        if (target >= TrimLevel.SkeletonOldCalls) {
+            const skeletonUntil = Math.max(0, pairs.length - index_js_1.appConfig.minToolPairKeep);
+            for (let i = 0; i < skeletonUntil; i++) {
+                skeletonizePair(working, pairs[i]);
+            }
+        }
+        // 2) 截断超出 keep 轮的旧工具负载（骨架化过的 pair 已经很小，重复处理无害）
         const clipUntil = Math.max(0, pairs.length - keep);
+        const argLimit = target >= TrimLevel.Aggressive
+            ? Math.max(200, Math.floor(index_js_1.appConfig.oldToolContentLimit / 2))
+            : index_js_1.appConfig.oldToolContentLimit;
         for (let i = 0; i < clipUntil; i++) {
-            clipPair(working, pairs[i], index_js_1.appConfig.oldToolContentLimit);
+            clipPair(working, pairs[i], argLimit);
         }
-        // 2) 降级旧附件
+        // 3) 降级旧附件
         if (target >= TrimLevel.Aggressive) {
             degradeAttachments(working, 1);
         }
-        // 3) 整对丢弃最早的工具调用（保持 assistant/tool 配对完整，避免协议错误）
-        if (target >= TrimLevel.DropOldPairs && pairs.length > index_js_1.appConfig.minToolPairKeep) {
-            const dropCount = pairs.length - index_js_1.appConfig.minToolPairKeep;
-            const dropIndexes = new Set();
-            for (let i = 0; i < dropCount; i++) {
-                for (let j = pairs[i].start; j < pairs[i].end; j++) {
-                    dropIndexes.add(j);
-                }
-            }
-            const dropped = working.filter((_, index) => !dropIndexes.has(index));
-            // 用提示说明被丢弃的轮次，避免模型认为自己没做过这些事。
-            // 注意：不能在对话中间插入 system 消息，部分厂商只允许 system 位于首位，
-            // 因此把提示并入首条 system 消息（没有则退化为 assistant 提示）。
-            const notice = `（已省略 ${dropCount} 轮较早的工具调用记录以控制上下文长度）`;
-            if (dropped[0]?.role === 'system' && typeof dropped[0].content === 'string') {
-                dropped[0] = { ...dropped[0], content: `${dropped[0].content}\n${notice}` };
-            }
-            else {
-                dropped.splice(protectFrom, 0, { role: 'assistant', content: notice, attachments: [] });
-            }
-            working = dropped;
+        // 4) 最后手段：折叠为账本（调用事实保留在 system 清单中）
+        if (target >= TrimLevel.FoldToLedger && pairs.length > index_js_1.appConfig.minToolPairKeep) {
+            working = foldPairsToLedger(working, pairs, pairs.length - index_js_1.appConfig.minToolPairKeep, protectFrom);
         }
     };
-    for (const target of [minLevel, TrimLevel.Aggressive, TrimLevel.DropOldPairs]) {
+    for (const target of [minLevel, TrimLevel.Aggressive, TrimLevel.SkeletonOldCalls, TrimLevel.FoldToLedger]) {
         if (target < level)
             continue;
         applyLevel(target);
@@ -252,8 +395,10 @@ exports.buildContext = buildContext;
 function nextTrimLevel(level) {
     if (level < TrimLevel.Aggressive)
         return TrimLevel.Aggressive;
-    if (level < TrimLevel.DropOldPairs)
-        return TrimLevel.DropOldPairs;
+    if (level < TrimLevel.SkeletonOldCalls)
+        return TrimLevel.SkeletonOldCalls;
+    if (level < TrimLevel.FoldToLedger)
+        return TrimLevel.FoldToLedger;
     return null;
 }
 exports.nextTrimLevel = nextTrimLevel;

package/dist/services/memory/MemoryManager.js

@@ -32,11 +32,21 @@ const index_js_1 = require("../../stores/index.js");
 const LLMClient_js_1 = require("../llm/LLMClient.js");
 const index_js_2 = require("../../config/index.js");
 const ContextBuilder_js_1 = require("./ContextBuilder.js");
+const ToolLedger_js_1 = require("./ToolLedger.js");
 const DEFAULT_CONFIG = {
     summaryThreshold: 10,
     summaryTriggerChars: index_js_2.appConfig.summaryTriggerChars,
     enabled: true,
 };
+/**
+ * 会话级压缩任务表：sessionId -> 进行中的压缩任务。
+ *
+ * 前台请求与后台预压缩共用这张表，确保同一会话同一时刻只有一次摘要生成：
+ * 否则两边会各自调用一次摘要模型（浪费配额），并竞争写入 lastMessageSummary。
+ */
+const compressionTasks = new Map();
+/** 后台预压缩的中断控制器，用于会话删除时取消 */
+const backgroundAborts = new Map();
 /** SSE 辅助方法：res 为 null 时跳过写入（本地执行模式） */
 const sendSSE = (res, data) => {
     if (!res)
@@ -61,10 +71,19 @@ class MemoryManager {
         this.childAgent = childAgent;
         this.res = res;
     }
-    toSummaryMessage(summary, createdAt, modelName) {
+    /**
+     * 构造注入上下文的摘要消息。
+     *
+     * @param omitted 被摘要（即不再出现在消息数组中）的原始消息。
+     *   这些消息的工具调用会被提取为「已完成操作」账本附在摘要之后，
+     *   防止模型因为看不到调用记录而重复执行同一个工具。
+     */
+    toSummaryMessage(summary, createdAt, modelName, omitted = []) {
+        const ledger = (0, ToolLedger_js_1.renderLedger)(omitted);
+        const content = `对话内容摘要：\n${summary}` + (ledger ? `\n\n${ledger}` : '');
         return {
             sessionId: this.session.id,
-            content: `对话内容摘要：\n${summary}`,
+            content,
             role: 'system',
             id: `summary_${createdAt}`,
             createdAt,
@@ -93,7 +112,10 @@ class MemoryManager {
             return fallback;
         return summarized[summarized.length - 1].createdAt;
     }
-    async getHistoryMessagesAsync() {
+    /**
+     * 制定压缩计划：只做判断与切分，不触发任何模型调用。
+     */
+    plan() {
         const keep = index_js_2.appConfig.historyKeep;
         // 复制数组：getMessages() 返回的是会话内部的活引用，不可原地修改
         let messages = [...this.session.getMessages()];
@@ -101,57 +123,189 @@ class MemoryManager {
             // 子 agent 的最后一条消息由调用方单独拼接，此处排除
             messages = messages.slice(0, -1);
         }
-        if (!this.shouldSummarize(messages)) {
-            return messages;
-        }
-        if (messages.length <= keep) {
-            return messages;
+        const empty = {
+            action: 'none', toSummarize: [], ledger: [], retained: messages,
+            newBoundaryAt: 0, prevBoundaryAt: null, prevLedger: [], prevRetained: messages,
+        };
+        if (!this.shouldSummarize(messages) || messages.length <= keep) {
+            return empty;
         }
-        const hasSummary = this.session.lastMessageSummary;
-        if (!hasSummary) {
-            // 首次摘要生成
+        if (!this.session.lastMessageSummary) {
             const toSummarize = messages.slice(0, -keep);
-            const summary = await this.generateSummaryAsync(toSummarize, null);
-            if (!summary) {
-                // 摘要失败/被中断：退回原始历史，不写入残缺摘要
-                return messages;
-            }
-            const boundary = this.boundaryOf(toSummarize, Date.now());
-            this.session.lastMessageSummary = summary;
-            this.session.lastMessageSummaryAt = boundary;
-            this.session.save();
-            return [
-                this.toSummaryMessage(summary, boundary, ''),
-                ...messages.slice(-keep),
-            ];
+            return {
+                action: 'first',
+                toSummarize,
+                ledger: toSummarize,
+                retained: messages.slice(-keep),
+                newBoundaryAt: this.boundaryOf(toSummarize, Date.now()),
+                prevBoundaryAt: null,
+                prevLedger: [],
+                prevRetained: messages,
+            };
         }
         // 增量摘要：边界之后的消息才是“新消息”
         const boundaryAt = this.session.lastMessageSummaryAt;
         const newMessages = messages.filter((m) => m.createdAt > boundaryAt);
+        // 边界之前的消息已被摘要取代，其工具调用需通过账本保留
+        const omitted = messages.filter((m) => m.createdAt <= boundaryAt);
         if (!this.shouldSummarize(newMessages) || newMessages.length <= keep) {
-            return [
-                this.toSummaryMessage(this.session.lastMessageSummary, boundaryAt, ''),
-                ...newMessages,
-            ];
+            return {
+                action: 'reuse',
+                toSummarize: [], ledger: [], retained: [],
+                newBoundaryAt: boundaryAt,
+                prevBoundaryAt: boundaryAt,
+                prevLedger: omitted,
+                prevRetained: newMessages,
+            };
         }
-        // 新消息超过阈值，基于旧摘要增量重算
         const toSummarize = newMessages.slice(0, -keep);
-        const summary = await this.generateSummaryAsync(toSummarize, this.session.lastMessageSummary);
-        if (!summary) {
-            return [
-                this.toSummaryMessage(this.session.lastMessageSummary, boundaryAt, ''),
-                ...newMessages,
-            ];
+        return {
+            action: 'incremental',
+            toSummarize,
+            ledger: [...omitted, ...toSummarize],
+            retained: newMessages.slice(-keep),
+            newBoundaryAt: this.boundaryOf(toSummarize, boundaryAt),
+            prevBoundaryAt: boundaryAt,
+            prevLedger: omitted,
+            prevRetained: newMessages,
+        };
+    }
+    /**
+     * 执行压缩计划并写入会话。
+     *
+     * @returns 摘要文本；null 表示失败/中断（调用方应沿用旧摘要或原始历史）
+     */
+    async runPlan(plan) {
+        if (plan.action !== 'first' && plan.action !== 'incremental')
+            return null;
+        const summary = await this.generateSummaryAsync(plan.toSummarize, plan.action === 'incremental' ? this.session.lastMessageSummary : null);
+        if (!summary)
+            return null;
+        // 并发保护：若边界已被其他压缩任务推进，说明有更新的摘要，放弃本次结果
+        if (plan.prevBoundaryAt !== null
+            && this.session.lastMessageSummaryAt !== plan.prevBoundaryAt) {
+            logger.info('摘要边界已被其他任务推进，丢弃本次压缩结果');
+            return null;
         }
-        const nextBoundary = this.boundaryOf(toSummarize, boundaryAt);
         this.session.lastMessageSummary = summary;
-        this.session.lastMessageSummaryAt = nextBoundary;
+        this.session.lastMessageSummaryAt = plan.newBoundaryAt;
         this.session.save();
+        return summary;
+    }
+    async getHistoryMessagesAsync() {
+        // 若后台预压缩正在进行，等它完成即可直接复用结果，避免重复调用摘要模型
+        const pending = compressionTasks.get(this.session.id);
+        if (pending) {
+            logger.debug('等待进行中的压缩任务完成');
+            try {
+                await pending;
+            }
+            catch {
+                // 后台任务失败不影响前台，重新按当前状态决策
+            }
+        }
+        const plan = this.plan();
+        if (plan.action === 'none') {
+            return plan.retained;
+        }
+        if (plan.action === 'reuse') {
+            return [
+                this.toSummaryMessage(this.session.lastMessageSummary, plan.prevBoundaryAt, '', plan.prevLedger),
+                ...plan.prevRetained,
+            ];
+        }
+        // 前台压缩同样登记到任务表，阻止后台预压缩重复执行
+        const task = this.runPlan(plan);
+        compressionTasks.set(this.session.id, task.then(() => undefined, () => undefined));
+        let summary = null;
+        try {
+            summary = await task;
+        }
+        finally {
+            compressionTasks.delete(this.session.id);
+        }
+        if (!summary) {
+            // 摘要失败/被中断：沿用旧摘要或退回原始历史，不写入残缺摘要
+            if (plan.action === 'incremental') {
+                return [
+                    this.toSummaryMessage(this.session.lastMessageSummary, plan.prevBoundaryAt, '', plan.prevLedger),
+                    ...plan.prevRetained,
+                ];
+            }
+            return plan.prevRetained;
+        }
         return [
-            this.toSummaryMessage(summary, nextBoundary, ''),
-            ...newMessages.slice(-keep),
+            this.toSummaryMessage(summary, plan.newBoundaryAt, '', plan.ledger),
+            ...plan.retained,
         ];
     }
+    /**
+     * 是否值得后台预压缩：仅当确实需要生成新摘要时才启动。
+     */
+    needsPrecompression() {
+        const action = this.plan().action;
+        return action === 'first' || action === 'incremental';
+    }
+    // ========== 后台预压缩 ==========
+    /**
+     * 在上一轮回复结束后于后台预先生成摘要，让下一轮请求直接命中结果。
+     *
+     * 设计要点：
+     * - 与前台共用 compressionTasks 表，同一会话不会重复调用摘要模型；
+     * - 失败只记日志，绝不抛出：预压缩是纯优化，失败时前台会自行压缩；
+     * - 使用独立 AbortController，不受上一轮请求的 signal 影响
+     *   （否则请求结束时 signal 被 abort，后台任务会立刻死掉）。
+     */
+    static schedulePrecompression(session) {
+        if (!index_js_2.appConfig.enablePrecompression)
+            return;
+        if (compressionTasks.has(session.id))
+            return;
+        // 正在生成时不预压缩：消息还会继续追加，此刻的摘要边界会立即过期
+        if (session.isGenerating)
+            return;
+        const controller = new AbortController();
+        const manager = new MemoryManager(session, controller.signal, true, null);
+        if (!manager.needsPrecompression())
+            return;
+        logger.info(`启动后台预压缩: session=${session.id}`);
+        backgroundAborts.set(session.id, controller);
+        const task = (async () => {
+            const startedAt = Date.now();
+            try {
+                const plan = manager.plan();
+                if (plan.action !== 'first' && plan.action !== 'incremental')
+                    return;
+                const summary = await manager.runPlan(plan);
+                if (summary) {
+                    logger.info(`后台预压缩完成: session=${session.id} 耗时=${Date.now() - startedAt}ms`);
+                }
+                else {
+                    logger.info(`后台预压缩未产生新摘要: session=${session.id}`);
+                }
+            }
+            catch (error) {
+                // 预压缩失败不影响任何用户可见行为
+                logger.warn(`后台预压缩失败: session=${session.id} ${error?.message}`);
+            }
+            finally {
+                compressionTasks.delete(session.id);
+                backgroundAborts.delete(session.id);
+            }
+        })();
+        compressionTasks.set(session.id, task);
+    }
+    /**
+     * 取消会话的后台预压缩（会话删除或用户重新发起请求时调用）
+     */
+    static cancelPrecompression(sessionId) {
+        const controller = backgroundAborts.get(sessionId);
+        if (controller) {
+            controller.abort();
+            backgroundAborts.delete(sessionId);
+            logger.debug(`已取消后台预压缩: session=${sessionId}`);
+        }
+    }
     /**
      * 格式化工具调用内容，提取关键信息供摘要模型理解
      */

package/dist/services/memory/ToolLedger.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderRequestLedger = exports.renderLedger = exports.renderOperations = exports.extractOperations = exports.extractOperationsFromRequest = void 0;
+/**
+ * 工具调用账本
+ *
+ * 当很早的工具调用连「骨架」都无法保留在消息数组中时（例如数百轮调用），
+ * 本模块把这些调用压成一份确定性的「已完成操作清单」，随摘要一起注入 system 消息。
+ *
+ * 为什么不交给 LLM 生成：
+ * 摘要由模型改写，操作清单一旦被模型漏写或改写，模型就会重复调用同一个工具。
+ * 因此账本从消息历史中**确定性提取**，每次实时重算，不依赖模型输出、也无需落库。
+ */
+/** 从参数中提取调用目标的关键字段，顺序即优先级 */
+const TARGET_KEYS = [
+    'path', 'filePath', 'file', 'filename', 'dir', 'directory',
+    'command', 'cmd', 'query', 'pattern', 'url', 'name', 'target', 'key',
+];
+/** 账本最多渲染的条目数，超出只保留计数 */
+const MAX_LEDGER_ENTRIES = 60;
+/** 单个目标字符串的最大长度 */
+const MAX_TARGET_LEN = 120;
+/** 从工具参数中提取一个可读的调用目标 */
+function extractTarget(input) {
+    if (input == null)
+        return '';
+    let parsed = input;
+    if (typeof input === 'string') {
+        try {
+            parsed = JSON.parse(input);
+        }
+        catch {
+            return input.length > MAX_TARGET_LEN ? input.slice(0, MAX_TARGET_LEN) + '…' : input;
+        }
+    }
+    if (!parsed || typeof parsed !== 'object')
+        return '';
+    for (const key of TARGET_KEYS) {
+        const value = parsed[key];
+        if (value == null || typeof value === 'object')
+            continue;
+        const text = String(value).trim();
+        if (!text)
+            continue;
+        return text.length > MAX_TARGET_LEN ? text.slice(0, MAX_TARGET_LEN) + '…' : text;
+    }
+    return '';
+}
+/**
+ * 从「请求态」消息数组中提取操作清单。
+ *
+ * 与 extractOperations 的区别在于数据形状：请求态消息用的是
+ * OpenAI 协议格式（assistant.tool_calls + 配对的 tool 消息），
+ * 而非会话持久化的 toolCalls 嵌套结构。
+ */
+function extractOperationsFromRequest(messages) {
+    const map = new Map();
+    // 先建立 tool_call_id -> 是否成功 的索引
+    const outcome = new Map();
+    for (const message of messages || []) {
+        if (message?.role !== 'tool' || !message.tool_call_id)
+            continue;
+        const text = typeof message.content === 'string' ? message.content : '';
+        let success = null;
+        try {
+            const parsed = JSON.parse(text);
+            if (parsed && typeof parsed.success === 'boolean')
+                success = parsed.success;
+        }
+        catch {
+            if (text.includes('[失败]'))
+                success = false;
+            else if (text.includes('[成功]'))
+                success = true;
+        }
+        outcome.set(message.tool_call_id, success);
+    }
+    for (const message of messages || []) {
+        if (message?.role !== 'assistant' || !Array.isArray(message.tool_calls))
+            continue;
+        for (const tc of message.tool_calls) {
+            const name = tc?.toolName || tc?.function?.name;
+            if (!name)
+                continue;
+            const target = extractTarget(tc.input ?? tc.function?.arguments);
+            const key = `${name}\u0000${target}`;
+            const success = tc.id ? (outcome.get(tc.id) ?? null) : null;
+            const existing = map.get(key);
+            if (existing) {
+                existing.count++;
+                if (success !== null)
+                    existing.lastSuccess = success;
+            }
+            else {
+                map.set(key, { tool: name, target, count: 1, lastSuccess: success });
+            }
+        }
+    }
+    return [...map.values()];
+}
+exports.extractOperationsFromRequest = extractOperationsFromRequest;
+/** 判断一次工具调用是否成功 */
+function isSuccess(item) {
+    if (item?.status === 'error')
+        return false;
+    if (item?.status === 'success')
+        return true;
+    return null;
+}
+/**
+ * 从消息中提取去重后的操作清单。
+ *
+ * 同一 工具+目标 的多次调用合并为一条并累加次数，
+ * 这样「读了 30 次同一个文件」不会占据 30 行。
+ */
+function extractOperations(messages) {
+    const map = new Map();
+    for (const message of messages || []) {
+        for (const group of (message.toolCalls || [])) {
+            for (const item of (group?.toolCalls || [])) {
+                if (!item?.toolName)
+                    continue;
+                const tool = item.actionName ? `${item.toolName}.${item.actionName}` : item.toolName;
+                const target = extractTarget(item.input);
+                const key = `${tool}\u0000${target}`;
+                const existing = map.get(key);
+                if (existing) {
+                    existing.count++;
+                    const success = isSuccess(item);
+                    if (success !== null)
+                        existing.lastSuccess = success;
+                }
+                else {
+                    map.set(key, { tool, target, count: 1, lastSuccess: isSuccess(item) });
+                }
+            }
+        }
+    }
+    return [...map.values()];
+}
+exports.extractOperations = extractOperations;
+/**
+ * 将操作清单渲染为文本。
+ *
+ * 返回空串表示没有需要记录的操作。
+ */
+function renderOperations(operations) {
+    if (operations.length === 0)
+        return '';
+    // 失败的操作最有价值（避免模型以为没做过而重试），优先展示；其次按调用次数
+    const sorted = operations.sort((a, b) => {
+        const aFailed = a.lastSuccess === false ? 1 : 0;
+        const bFailed = b.lastSuccess === false ? 1 : 0;
+        if (aFailed !== bFailed)
+            return bFailed - aFailed;
+        return b.count - a.count;
+    });
+    const shown = sorted.slice(0, MAX_LEDGER_ENTRIES);
+    const lines = shown.map((op) => {
+        const times = op.count > 1 ? ` ×${op.count}` : '';
+        const flag = op.lastSuccess === false ? ' [失败]' : '';
+        const target = op.target ? ` ${op.target}` : '';
+        return `- ${op.tool}${target}${times}${flag}`;
+    });
+    const rest = sorted.length - shown.length;
+    if (rest > 0) {
+        lines.push(`- …另有 ${rest} 项操作未列出`);
+    }
+    return `【已完成操作】以下工具调用**已经执行过**，除非需要确认最新状态，不要重复调用：\n${lines.join('\n')}`;
+}
+exports.renderOperations = renderOperations;
+/** 从会话消息渲染账本 */
+function renderLedger(messages) {
+    return renderOperations(extractOperations(messages));
+}
+exports.renderLedger = renderLedger;
+/** 从请求态消息渲染账本 */
+function renderRequestLedger(messages) {
+    return renderOperations(extractOperationsFromRequest(messages));
+}
+exports.renderRequestLedger = renderRequestLedger;

package/dist/services/session/Session.js

@@ -106,11 +106,16 @@ class Session {
     lastMessageSummary = null;
     lastMessageSummaryAt = null;
     isCurrent;
+    // 计划模式：当前需求拆分出的执行计划
+    plan = [];
+    planUpdatedAt = null;
     // 用于停止生成
     isGenerating = false;
     unreadCount = 0;
     currentMessageId = null;
     abortController = null;
+    /** 后台预压缩的延迟定时器 */
+    precompressionTimer = null;
     toInsertMessages;
     constructor(data) {
         this.id = data.id;
@@ -437,6 +442,59 @@ class Session {
         this.unreadCount++;
         this.save();
     }
+    // ========== 计划模式 ==========
+    /**
+     * 更新当前会话的执行计划（全量替换）
+     */
+    updatePlan(steps) {
+        this.plan = steps.map(item => ({ step: item.step, status: item.status }));
+        this.planUpdatedAt = Date.now();
+        return this.plan;
+    }
+    /**
+     * 清除当前会话的执行计划
+     */
+    clearPlan() {
+        this.plan = [];
+        this.planUpdatedAt = null;
+    }
+    /**
+     * 计划是否已全部完成
+     */
+    isPlanCompleted() {
+        return this.plan.length > 0 && this.plan.every(item => item.status === 'completed');
+    }
+    /**
+     * 构造计划进度提醒。
+     *
+     * 模型倾向于只在任务开头和结尾调用 updatePlan，导致界面进度长期停在第一项。
+     * 因此当会话已有计划、且连续 roundsSincePlanUpdate 轮工具调用都没有同步进度时，
+     * 返回一条提醒文案注入上下文；无需提醒时返回 null。
+     */
+    buildPlanReminder(roundsSincePlanUpdate) {
+        // 没有计划或计划已完成，无需提醒
+        if (this.plan.length === 0 || this.isPlanCompleted())
+            return null;
+        // 允许模型连续做 1 轮工具调用后再要求同步，避免过于频繁地打断
+        if (roundsSincePlanUpdate < 2)
+            return null;
+        const current = this.plan.find(item => item.status === 'in_progress');
+        const nextPending = this.plan.find(item => item.status === 'pending');
+        const completed = this.plan.filter(item => item.status === 'completed').length;
+        const lines = [
+            `【计划进度提醒】当前计划共 ${this.plan.length} 步，已完成 ${completed} 步，`
+                + `已连续 ${roundsSincePlanUpdate} 轮工具调用未同步计划状态。`,
+        ];
+        if (current) {
+            lines.push(`进行中的步骤是「${current.step}」：如果它已经做完，请立即调用 updatePlan 把它置为 completed`
+                + `${nextPending ? `，并把「${nextPending.step}」置为 in_progress` : ''}。`);
+        }
+        else if (nextPending) {
+            lines.push(`当前没有进行中的步骤，请立即调用 updatePlan 把「${nextPending.step}」置为 in_progress。`);
+        }
+        lines.push('调用时必须传入完整步骤列表，且同一时刻最多一个步骤为 in_progress。');
+        return lines.join('\n');
+    }
     // 清除未读消息数并持久化
     clearUnreadCount() {
         this.unreadCount = 0;
@@ -489,6 +547,12 @@ class Session {
                 this.stopGenerating();
             }
         }
+        // 上一轮计划已全部完成，新一轮需求开始前清空，避免残留在界面上
+        if (this.isPlanCompleted()) {
+            this.clearPlan();
+        }
+        // 新请求到来：放弃排队中的预压缩，避免与前台压缩重复调用摘要模型
+        this.abortPrecompression();
         // Add user message
         this.getAbortController();
         this.isGenerating = true;
@@ -579,6 +643,8 @@ class Session {
             : (await dataService_js_1.modelsService.list(token)).data.map(x => (0, models_js_1.toModel)(x));
         // 工具调用轮次计数，防止无限循环
         let toolRound = 0;
+        // 计划模式：距上次调用 updatePlan 已经过的工具轮次，用于在中间过程强制提醒模型同步进度
+        let roundsSincePlanUpdate = 0;
         // 当前裁剪级别，遇到上下文超限时逐级加重
         let trimLevel = ContextBuilder_js_1.TrimLevel.OldToolPayload;
         /** 判断错误是否为上下文超限 */
@@ -901,6 +967,9 @@ class Session {
                 };
                 await Promise.all(llmResult.toolCalls.map(x => startToolCall(x)));
                 toolCalls.push(toolCall);
+                // 计划模式：本轮是否调用了 updatePlan
+                const calledUpdatePlan = llmResult.toolCalls.some((tc) => tc.toolName === 'updatePlan');
+                roundsSincePlanUpdate = calledUpdatePlan ? 0 : roundsSincePlanUpdate + 1;
                 // 将工具结果添加到消息历史（格式化为 tool 角色的消息）
                 for (const result of toolResults) {
                     const toolResultMessage = {
@@ -915,6 +984,17 @@ class Session {
                     };
                     messages.push(toolResultMessage);
                 }
+                // 计划模式：模型常常只在开头和结尾调用 updatePlan，中间过程不同步进度。
+                // 这里在已有计划且连续多轮未同步时，主动注入一条提醒，迫使模型推进计划状态。
+                const reminder = this.buildPlanReminder(roundsSincePlanUpdate);
+                if (reminder) {
+                    messages.push({
+                        role: 'assistant',
+                        content: reminder,
+                        attachments: []
+                    });
+                    roundsSincePlanUpdate = 0;
+                }
                 // 继续下一轮（带上工具结果继续调用模型）
                 return await processModelResponse();
             }
@@ -982,14 +1062,57 @@ class Session {
                 if (this.currentMessageId !== null) {
                     this.saveMessage();
                 }
+                // 后台预压缩：本轮已结束，提前生成摘要让下一轮直接命中，降低首字延迟。
+                // 延迟启动是为了给用户的连续追问让路（追问会取消它）。
+                this.schedulePrecompression();
             }
         }
     }
+    /**
+     * 延迟调度后台预压缩。
+     *
+     * 不 await：预压缩是纯优化，绝不能阻塞本轮请求的收尾。
+     */
+    schedulePrecompression() {
+        if (!index_js_2.appConfig.enablePrecompression)
+            return;
+        this.cancelPrecompressionTimer();
+        this.precompressionTimer = setTimeout(() => {
+            this.precompressionTimer = null;
+            try {
+                MemoryManager_js_1.MemoryManager.schedulePrecompression(this);
+            }
+            catch (error) {
+                logger.warn('调度后台预压缩失败:', error?.message);
+            }
+        }, index_js_2.appConfig.precompressionDelay);
+        // 不阻止进程退出
+        this.precompressionTimer.unref?.();
+    }
+    /** 取消尚未触发的预压缩定时器 */
+    cancelPrecompressionTimer() {
+        if (this.precompressionTimer) {
+            clearTimeout(this.precompressionTimer);
+            this.precompressionTimer = null;
+        }
+    }
+    /**
+     * 用户发起新请求或会话销毁时，放弃排队中/进行中的预压缩。
+     *
+     * 前台会自行压缩，且新消息会使预压缩的边界立即过期。
+     */
+    abortPrecompression() {
+        this.cancelPrecompressionTimer();
+        MemoryManager_js_1.MemoryManager.cancelPrecompression(this.id);
+    }
     /**
      * 停止当前正在进行的生成
      */
     stopGenerating() {
         this.isGenerating = false;
+        this.abortPrecompression();
+        // 停止生成后清除计划，避免 Desktop 的进度圈停留在未完成状态
+        this.clearPlan();
         if (this.abortController) {
             this.abortController.abort();
             this.abortController = null;

package/dist/services/session/SessionManager.js

@@ -149,6 +149,8 @@ class SessionManager {
         const session = this.sessions.get(sessionId);
         if (!session)
             return false;
+        // 先取消后台预压缩：否则任务完成后会向已删除的会话写入摘要
+        session.abortPrecompression();
         SessionStore_js_1.sessionStore.transaction(() => {
             SessionStore_js_1.sessionStore.deleteMessagesBySessionId(sessionId);
             SessionStore_js_1.sessionStore.deleteSession(sessionId);

package/dist/services/systemPrompt.js

@@ -79,26 +79,26 @@ function getChatStyle(settings) {
 function getIndentityInfoAsync(settings, agent) {
     const style = getChatStyle(settings);
     const agentName = agent?.name || settings.agentName || settings.assistantName;
-    return `【身份】
-- 你是「${agentName}」，${settings.userName}的智能助手。${style}
+    return `【身份】
+- 你是「${agentName}」，${settings.userName}的智能助手。${style}
 - 自称"我"，称用户为"您"或「${settings.userName}」`;
 }
 function getInstalledSkillsPrompt(skills) {
     // 替换技能列表（模板中应该有占位符，如 {{skills}}）
     const skillsList = skills.map((skill, index) => `skillId: "${skill.id}". **${skill.name}** - ${skill.description || '无描述'}`).join('\n');
     const skillSystemPrompt = `【技能系统】当你出现无法解决用户需求时，需要通过技能系统来帮助完成。 技能有两种，一种是通过skill工具可以获取到的技能，一种是通过clawhub安装的技能。`;
-    const skillToolPrompt = `【skill工具技能】
-    【已安装skill技能】
-    ${skillsList}
-    【强制调用流程】
-    1.必须先调用技能管理工具获取详情
-    2.如果技能的scriptsUrl不为空，并且当前目录中的skills目录下不存在对应的技能，需要先下载，然后解压后才可以使用，下载目录统一下载到当前目录的skills目录下的该技能目录。
+    const skillToolPrompt = `【skill工具技能】
+    【已安装skill技能】
+    ${skillsList}
+    【强制调用流程】
+    1.必须先调用技能管理工具获取详情
+    2.如果技能的scriptsUrl不为空，并且当前目录中的skills目录下不存在对应的技能，需要先下载，然后解压后才可以使用，下载目录统一下载到当前目录的skills目录下的该技能目录。
     3.下载直接使用命令行工具，不要使用fetch工具。运行完脚本记得把脚本及其解压内容删除。`;
-    const clawhubSkillPrompt = `
-    【clawhub技能】
-    1.通过clawhub安装的技能，首先通过命令行工具查看clawhub命令是否安装
-    2.如果没有安装需要先安装clawhub
-    3.如果已经安装可以使用clawhub search命令搜索相关工具
+    const clawhubSkillPrompt = `
+    【clawhub技能】
+    1.通过clawhub安装的技能，首先通过命令行工具查看clawhub命令是否安装
+    2.如果没有安装需要先安装clawhub
+    3.如果已经安装可以使用clawhub search命令搜索相关工具
     4.安装后根据技能中的SKILL.md文档描述进行使用`;
     return `\n${skillSystemPrompt}\n${skillToolPrompt}\n${clawhubSkillPrompt}\n`;
 }
@@ -116,46 +116,55 @@ async function getSystemPromptAsync(agent, customPrompt) {
     const skillPrompts = getInstalledSkillsPrompt(skills);
     const chineseLocalName = exports.LANGUAGES.filter(x => x.code === settings.language)[0]?.chineseName ?? '简体中文';
     const date = new Date();
-    let prompt = `${getIndentityInfoAsync(settings, agent)}。
-  【当前运行环境】：${osInfo}。
-  【当前时间】：${date.toLocaleString(settings.language)},weekday:${date.getDay()}。
-  【语言】你的回复语言严格遵循用户设备系统语言：${chineseLocalName}，无论用户使用任何语言提问，你都只使用【${chineseLocalName}】进行完整回复，不要混用其他语言。
-  【尽力原则】充分分析用户需求，尽力满足，不要偷懒，不要得过且过，要诚实，不能胡编乱造。
-  【工具调用】
-  1.逐步思考，分步骤调用工具，工具调用前尽量返回content，明确当前工具调用的目的。
-  2.工具调用的参数全部采用JSON语法，调用前先验证JSON语法正确后，再回复，切记未验证JSON语法就直接回复。
-  【命令执行】执行命令时一定要根据当前系统来执行命令
-  【文件操作】
-  1.文件编辑后一定要验证编辑是否成功，文件内容与预期是否一致。
-  2.文件工具目前未提供批量替换操作，如果需要批量修改，请自行创建脚本来完成。
-  3.大文件写入如果无法识别，请先写入主体内容，再使用edit工具进行修改来操作
-  【特殊语法】mermaid折线图需要使用xychart-beta，完整示例如下：
-  xychart-beta
-    title "2025年上半年产品销量对比"
-    x-axis ["1月", "2月", "3月", "4月", "5月", "6月"]
-    y-axis "销量 (件)" 0 --> 80
-    line "智能手机" [45, 52, 38, 65, 58, 72]
-    line "笔记本电脑" [30, 28, 35, 42, 38, 45]
-    line "平板电脑" [20, 25, 30, 28, 35, 40]
-  【解决问题思路】
-  1.首先分析用户需求，根据需求罗列出实施计划。如果对需求不够明确，需要把计划罗列完后，让用户确认后再执行。
-  2.按照计划分步执行
-  3.所有步骤完成后，验证结果，比如编写程序，则需要执行类型检查
-  4.验证完全通过，总结完成情况，告诉用户
-  【代码规范】
-  ## 1 面向对象代码设计
-  1）根据功能先添加接口
-  2）对应接口添加一个基类
-  3）实现类默认继承这个基类
-  ## 2 添加新功能
-  1）服务端根据DDD架构，进行分层设计：控制器、服务、领域服务
-  2）客户端将一个页面分为3部分，页面组件、页面样式、页面执行的脚本，页面执行的脚本中，数据服务与业务逻辑分开处理，数据服务又分为本地数据和远程数据
-  ## 3 修改已经存在的代码文件
-  1）修改Bug，找到Bug后精确替换，不要调整架构
-  2）修改业务功能，删除旧的业务功能，重新添加新的，不要在旧的上面做修改，直接删除旧功能，然后添加新功能
- 【代码提交】务必类型检查通过
- 【任务完成过程中】不能独白
- 【会话标题】任务开始前，先修改会话标题，标题必须简洁明了，能概括任务内容
+    let prompt = `${getIndentityInfoAsync(settings, agent)}。
+  【当前运行环境】：${osInfo}。
+  【当前时间】：${date.toLocaleString(settings.language)},weekday:${date.getDay()}。
+  【语言】你的回复语言严格遵循用户设备系统语言：${chineseLocalName}，无论用户使用任何语言提问，你都只使用【${chineseLocalName}】进行完整回复，不要混用其他语言。
+  【尽力原则】充分分析用户需求，尽力满足，不要偷懒，不要得过且过，要诚实，不能胡编乱造。
+  【工具调用】
+  1.逐步思考，分步骤调用工具，工具调用前尽量返回content，明确当前工具调用的目的。
+  2.工具调用的参数全部采用JSON语法，调用前先验证JSON语法正确后，再回复，切记未验证JSON语法就直接回复。
+  【命令执行】执行命令时一定要根据当前系统来执行命令
+  【文件操作】
+  1.文件编辑后一定要验证编辑是否成功，文件内容与预期是否一致。
+  2.文件工具目前未提供批量替换操作，如果需要批量修改，请自行创建脚本来完成。
+  3.大文件写入如果无法识别，请先写入主体内容，再使用edit工具进行修改来操作
+  【特殊语法】mermaid折线图需要使用xychart-beta，完整示例如下：
+  xychart-beta
+    title "2025年上半年产品销量对比"
+    x-axis ["1月", "2月", "3月", "4月", "5月", "6月"]
+    y-axis "销量 (件)" 0 --> 80
+    line "智能手机" [45, 52, 38, 65, 58, 72]
+    line "笔记本电脑" [30, 28, 35, 42, 38, 45]
+    line "平板电脑" [20, 25, 30, 28, 35, 40]
+  【解决问题思路】
+  1.首先分析用户需求，根据需求罗列出实施计划。如果对需求不够明确，需要把计划罗列完后，让用户确认后再执行。
+  2.按照计划分步执行
+  3.所有步骤完成后，验证结果，比如编写程序，则需要执行类型检查
+  4.验证完全通过，总结完成情况，告诉用户
+  【计划模式】
+  1.当用户需求需要拆分成两步以上才能完成时，必须先调用 updatePlan 工具给出完整的计划步骤（每步 status 初始为 pending，第一步直接置为 in_progress）。
+  2.**每完成一个步骤就必须立刻调用一次 updatePlan**：把刚完成的步骤置为 completed，把下一个要做的步骤置为 in_progress。禁止只在开头和结尾各调用一次、中间全程不同步——这会让用户界面的进度一直停在第一项。
+  3.判断标准：只要你准备开始做「下一个步骤」的事情，就说明上一个步骤已完成，此时必须先调用 updatePlan 再继续。
+  4.每次调用 updatePlan 都要传入完整步骤列表，不要只传变化的部分；同一时刻最多一个步骤为 in_progress。
+  5.计划步骤描述要简洁（建议不超过 30 字），可执行、可验证，不要写"分析需求""总结"之类的空步骤。
+  6.如果收到【计划进度提醒】，说明你已多轮未同步进度，必须立即调用 updatePlan 修正状态。
+  7.任务结束前必须把所有步骤都置为 completed，否则用户界面的计划进度圈不会消失。
+  8.一句话就能答完的简单需求不要调用 updatePlan。
+  【代码规范】
+  ## 1 面向对象代码设计
+  1）根据功能先添加接口
+  2）对应接口添加一个基类
+  3）实现类默认继承这个基类
+  ## 2 添加新功能
+  1）服务端根据DDD架构，进行分层设计：控制器、服务、领域服务
+  2）客户端将一个页面分为3部分，页面组件、页面样式、页面执行的脚本，页面执行的脚本中，数据服务与业务逻辑分开处理，数据服务又分为本地数据和远程数据
+  ## 3 修改已经存在的代码文件
+  1）修改Bug，找到Bug后精确替换，不要调整架构
+  2）修改业务功能，删除旧的业务功能，重新添加新的，不要在旧的上面做修改，直接删除旧功能，然后添加新功能
+ 【代码提交】务必类型检查通过
+ 【任务完成过程中】不能独白
+ 【会话标题】任务开始前，先修改会话标题，标题必须简洁明了，能概括任务内容
   ${skillPrompts}`;
     // 如果有自定义提示词，追加
     if (customPrompt) {

package/dist/services/tools/index.js

@@ -37,10 +37,11 @@ const edit_js_1 = require("./edit.js");
 const webFetch_js_1 = require("./webFetch.js");
 const sessionsSpawn_js_1 = require("./sessionsSpawn.js");
 const setSessionTitle_js_1 = require("./setSessionTitle.js");
+const plan_js_1 = require("./plan.js");
 exports.tools = [
     search_js_1.searchTool, calculator_js_1.calculatorTool, screenshot_js_1.screenshotTool, keyboard_js_1.keyboardTool, mouse_js_1.mouseTool,
     skill_js_1.skillTool, exec_js_1.execTool, task_js_1.taskTool, model_js_1.modelTool, fetch_js_1.fetchTool,
-    edit_js_1.editTool, webFetch_js_1.webFetchTool, file_js_1.fileTool, sessionsSpawn_js_1.sessionsSpawnTool, setSessionTitle_js_1.setSessionTitleTool
+    edit_js_1.editTool, webFetch_js_1.webFetchTool, file_js_1.fileTool, sessionsSpawn_js_1.sessionsSpawnTool, setSessionTitle_js_1.setSessionTitleTool, plan_js_1.updatePlanTool
 ];
 function getToolByName(name) {
     return exports.tools.find(tool => tool.name === name);

package/dist/services/tools/plan.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePlanTool = void 0;
+const SessionManager_js_1 = require("../session/SessionManager.js");
+const WebSocketService_js_1 = require("../WebSocketService.js");
+const shared_1 = require("@myassis/shared");
+const logger = (0, shared_1.getLogger)('PlanTool');
+const VALID_STATUS = ['pending', 'in_progress', 'completed'];
+/**
+ * 规范化计划步骤，过滤非法数据
+ */
+function normalizeSteps(steps) {
+    if (!Array.isArray(steps) || steps.length === 0)
+        return null;
+    const normalized = [];
+    for (const item of steps) {
+        if (!item)
+            continue;
+        const step = typeof item === 'string' ? item : item.step;
+        if (typeof step !== 'string' || step.trim().length === 0)
+            continue;
+        const status = VALID_STATUS.includes(item?.status) ? item.status : 'pending';
+        normalized.push({ step: step.trim(), status });
+    }
+    return normalized.length > 0 ? normalized : null;
+}
+exports.updatePlanTool = {
+    name: 'updatePlan',
+    description: `维护当前需求的多步执行计划（计划模式）。
+当用户需求需要拆分成两步以上才能完成时，必须先调用本工具给出完整的计划步骤。
+调用后 Desktop 会话底部会显示计划进度圈，鼠标悬浮可查看每个步骤的状态。
+规则：
+1. 每完成一个步骤都必须立刻再调用一次本工具：把已完成步骤置为 completed，把下一个步骤置为 in_progress。
+   禁止只在任务开头和结尾各调用一次，中间不同步会导致用户看到的进度一直停在第一项。
+2. 每次调用都要传入完整的步骤列表（含已完成步骤），不要只传增量。
+3. 同一时刻最多只有一个步骤处于 in_progress。
+4. 全部步骤都变为 completed 后，进度圈才会消失，所以任务结束时务必把最后一个步骤标记为 completed。`,
+    parameters: {
+        type: 'object',
+        properties: {
+            steps: {
+                type: 'array',
+                description: '完整的计划步骤列表，按执行顺序排列',
+                items: {
+                    type: 'object',
+                    description: '单个计划步骤',
+                    properties: {
+                        step: { type: 'string', description: '步骤描述，简洁明确，建议不超过 30 字' },
+                        status: {
+                            type: 'string',
+                            description: '步骤状态：pending 待完成、in_progress 进行中、completed 已完成',
+                            enum: ['pending', 'in_progress', 'completed'],
+                            default: 'pending',
+                        },
+                    },
+                    required: ['step', 'status'],
+                },
+            },
+            explanation: {
+                type: 'string',
+                description: '可选，本次计划变更的简要说明',
+            },
+        },
+        required: ['steps'],
+    },
+    handler: async (args, sessionId, _messageId, userId) => {
+        try {
+            const steps = normalizeSteps(args?.steps);
+            if (!steps) {
+                return { success: false, errorMessage: '计划步骤不能为空，steps 需要是 [{ step, status }] 数组' };
+            }
+            if (steps.filter(s => s.status === 'in_progress').length > 1) {
+                return { success: false, errorMessage: '同一时刻最多只能有一个步骤处于 in_progress' };
+            }
+            if (!sessionId) {
+                return { success: false, errorMessage: '无当前会话，无法更新计划' };
+            }
+            if (!userId) {
+                return { success: false, errorMessage: '未登录' };
+            }
+            const session = (0, SessionManager_js_1.getSessionManager)(String(userId)).getSession(sessionId);
+            if (!session) {
+                return { success: false, errorMessage: '会话不存在' };
+            }
+            session.updatePlan(steps);
+            // 推送计划进度到 Desktop，驱动底部进度圈刷新
+            WebSocketService_js_1.webSocketService.sendToUser(String(userId), {
+                type: 'plan_updated',
+                payload: {
+                    sessionId,
+                    agentId: session.agentId,
+                    steps: session.plan,
+                    updatedAt: session.planUpdatedAt,
+                },
+            });
+            const completed = steps.filter(s => s.status === 'completed').length;
+            return {
+                success: true,
+                output: JSON.stringify({
+                    total: steps.length,
+                    completed,
+                    steps,
+                }),
+            };
+        }
+        catch (error) {
+            logger.error('更新计划失败:', error);
+            return { success: false, errorMessage: `更新计划失败: ${error?.message}` };
+        }
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myassis/gateway",
-  "version": "1.0.78",
+  "version": "1.0.82",
   "description": "我的助手 Gateway Service - 本地 AI 网关服务，支持认证、WebSocket 实时通信和任务调度",
   "main": "dist/index.js",
   "bin": {