@myassis/gateway 1.0.81 → 1.0.83

package/dist/config/index.js

@@ -91,6 +91,10 @@ exports.appConfig = {
     oldToolContentLimit: parseInt(process.env.OLD_TOOL_CONTENT_LIMIT || '500', 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/main.js

@@ -31,6 +31,21 @@ const WebSocketService_js_1 = require("./services/WebSocketService.js");
 const TaskSchedulerService_js_1 = require("./services/TaskSchedulerService.js");
 const ServiceManager_js_1 = require("./services/ServiceManager.js");
 const logger = (0, shared_1.getLogger)('index');
+// 内置放通的官方域名（含子域名），无需用户手动 addCors
+const DEFAULT_CORS_DOMAINS = ['my-assis.com'];
+// 判断来源主机是否命中某个域名（自身或其子域名）
+function matchDomain(originHost, domain) {
+    // 允许配置成裸域名（app.example.com）、带协议的完整来源（https://app.example.com）或通配符（*.example.com）
+    const d = domain
+        .trim()
+        .toLowerCase()
+        .replace(/^https?:\/\//, '')
+        .replace(/\/.*$/, '')
+        .replace(/^\*\./, '');
+    if (!d)
+        return false;
+    return originHost === d || originHost.endsWith('.' + d);
+}
 // ─── CLI 模式 ─────────────────────────────────────────
 // gateway install | start | stop | uninstall | status | update
 const cliCommand = process.argv[2];
@@ -137,9 +152,11 @@ if (cliCommand) {
                 }
             }
             else if (cliCommand === 'listCors') {
+                console.log(`内置 CORS 域名 (${DEFAULT_CORS_DOMAINS.length}):`);
+                DEFAULT_CORS_DOMAINS.forEach(d => console.log(`  - *.${d}`));
                 const domains = persistStore_js_1.persistStore.getCorsDomains();
                 if (domains.length === 0) {
-                    console.log('暂无自定义 CORS 域名（仅使用内置内网规则）');
+                    console.log('暂无自定义 CORS 域名（仅使用内置内网与内置域名规则）');
                 }
                 else {
                     console.log(`自定义 CORS 域名 (${domains.length}):`);
@@ -147,35 +164,27 @@ if (cliCommand) {
                 }
             }
             else if (cliCommand === '--help' || cliCommand === '-h') {
-                console.log(`我的助手 Gateway CLI
-
-用法: gateway <命令>
-
-服务管理命令:
-  install       安装 Gateway 服务（后台运行）
-  uninstall     卸载 Gateway 服务
-  start         启动 Gateway 服务
-  stop          停止 Gateway 服务
-  restart       重启 Gateway 服务
-  update        更新 Gateway（需重新安装）
-  status        查看服务状态
-
-CORS 管理命令:
-  addCors <域名>      添加允许的跨域域名
-  removeCors <域名>    移除允许的跨域域名
-  listCors            列出所有自定义跨域域名
-
-其他:
-  --help, -h          显示本帮助信息
+                console.log(`我的助手 Gateway CLI
+
+用法: gateway <命令>
+
+服务管理命令:
+  install       安装 Gateway 服务（后台运行）
+  uninstall     卸载 Gateway 服务
+  start         启动 Gateway 服务
+  stop          停止 Gateway 服务
+  restart       重启 Gateway 服务
+  update        更新 Gateway（需重新安装）
+  status        查看服务状态
+
+CORS 管理命令:
+  addCors <域名>      添加允许的跨域域名
+  removeCors <域名>    移除允许的跨域域名
+  listCors            列出所有跨域域名（含内置域名）
+
+其他:
+  --help, -h          显示本帮助信息
 `);
-                const domains = persistStore_js_1.persistStore.getCorsDomains();
-                if (domains.length === 0) {
-                    console.log('暂无自定义 CORS 域名（仅使用内置内网规则）');
-                }
-                else {
-                    console.log(`自定义 CORS 域名 (${domains.length}):`);
-                    domains.forEach(d => console.log(`  - ${d}`));
-                }
             }
             else {
                 const fnMap = {
@@ -233,19 +242,31 @@ else {
             if (lanPatterns.some(pattern => pattern.test(origin))) {
                 return callback(null, true);
             }
-            // 检查自定义域名（支持子域名匹配）
-            const customDomains = persistStore_js_1.persistStore.getCorsDomains();
-            const originLower = origin.toLowerCase();
-            if (customDomains.some(d => {
-                const dLower = d.toLowerCase();
-                return originLower === dLower || originLower.endsWith('.' + dLower);
-            })) {
+            let originHost = '';
+            try {
+                originHost = new URL(origin).hostname.toLowerCase();
+            }
+            catch {
+                originHost = origin.toLowerCase();
+            }
+            // 检查内置官方域名与用户自定义域名（均支持子域名匹配）
+            const allowedDomains = [...DEFAULT_CORS_DOMAINS, ...persistStore_js_1.persistStore.getCorsDomains()];
+            if (allowedDomains.some(d => matchDomain(originHost, d))) {
                 return callback(null, true);
             }
             callback(new Error('Not allowed by CORS'));
         },
         credentials: true,
     };
+    // Chrome Private Network Access：公网页面（网页版）访问本机 Gateway 时，
+    // 预检请求会带 Access-Control-Request-Private-Network，必须显式放行。
+    // 必须注册在 cors() 之前，否则 cors 会先结束 OPTIONS 预检，响应头加不上。
+    app.use((req, res, next) => {
+        if (req.headers['access-control-request-private-network']) {
+            res.setHeader('Access-Control-Allow-Private-Network', 'true');
+        }
+        next();
+    });
     app.use((0, cors_1.default)(corsOptions));
     app.use(express_1.default.json({ limit: '10mb' }));
     // Health check

package/dist/services/ServiceManager.js

@@ -112,65 +112,168 @@ function getStoredPid() {
  *   - 因此自杀场景改走 process.emit('SIGTERM')，复用 main.ts 已注册的优雅关闭逻辑，
  *     并在响应返回后异步退出，避免 HTTP 调用方读不到结果。
  */
-async function stopGatewayProcess() {
-    const pid = getStoredPid();
-    if (!pid)
+/**
+ * 探测进程是否存活（signal 0 不会真的发信号）
+ */
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 轮询等待指定进程退出，返回是否已退出
+ */
+async function waitForPidExit(pid, timeoutMs) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        if (!isPidAlive(pid))
+            return true;
+        await new Promise(r => setTimeout(r, 200));
+    }
+    return !isPidAlive(pid);
+}
+/**
+ * 读取守护进程 PID
+ */
+function getDaemonPid() {
+    try {
+        if (!fs_1.default.existsSync(GATEWAY_DAEMON_PID_FILE))
+            return null;
+        // 去除 PowerShell Out-File -Encoding UTF8 写入的 BOM，否则 parseInt 会得到 NaN
+        const raw = fs_1.default.readFileSync(GATEWAY_DAEMON_PID_FILE, 'utf8').replace(/^\uFEFF/, '').trim();
+        const pid = parseInt(raw, 10);
+        return isNaN(pid) ? null : pid;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 结束守护进程（运行 launcher.ps1 的那个 PowerShell）
+ *
+ * 必须在结束 gateway 之前调用：守护进程每 5s 轮询一次，若发现 gateway 已退出
+ * 且此刻停止标记不存在，就会立即重新拉起，表现为「stop 之后网关又活了」。
+ */
+async function stopDaemonProcess() {
+    if (process.platform !== 'win32')
         return;
-    // —— 场景 1：要停的就是自己 —— 走优雅退出
-    if (pid === process.pid) {
+    const daemonPid = getDaemonPid();
+    if (daemonPid && daemonPid !== process.pid && isPidAlive(daemonPid)) {
         try {
-            fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+            process.kill(daemonPid, 'SIGTERM');
         }
         catch { /* ignore */ }
-        // 异步触发，确保当前调用栈（含 HTTP 响应）有机会先返回
-        setTimeout(() => {
+        if (!(await waitForPidExit(daemonPid, 3000))) {
             try {
-                process.emit('SIGTERM');
+                process.kill(daemonPid, 'SIGKILL');
             }
             catch { /* ignore */ }
-            // 兜底：5s 内 SIGTERM handler 没把进程关掉，再强退
-            setTimeout(() => process.exit(0), 5000).unref();
-        }, 100).unref();
-        return;
-    }
-    // —— 场景 2：停的是别人（孤儿进程 / 旧实例）—— 才真正发信号
-    try {
-        process.kill(pid, 'SIGTERM');
-        await new Promise(r => setTimeout(r, 2000));
+            await waitForPidExit(daemonPid, 2000);
+        }
     }
-    catch { /* ignore */ }
-    // 强制终止（如果还没退出）
     try {
-        process.kill(pid, 'SIGKILL');
+        fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
     }
     catch { /* ignore */ }
+}
+/**
+ * PID 文件丢失/过期时的兜底：按 exe 路径匹配并结束 gateway 进程
+ *
+ * PID 文件位于 %TEMP%，可能被系统清理策略删除，此时仅靠 PID 会漏杀。
+ * 仅在打包为 exe 时启用：开发模式下 execPath 是 node.exe，按路径匹配会误杀其它 Node 进程。
+ */
+async function stopGatewayByExePath() {
+    if (process.platform !== 'win32' || !isPackagedExe())
+        return 0;
+    const exe = process.execPath;
+    const name = path_1.default.basename(exe, path_1.default.extname(exe));
+    const q = (v) => v.replace(/'/g, "''");
     try {
-        fs_1.default.unlinkSync(GATEWAY_PID_FILE);
-    }
-    catch { /* ignore */ }
-    // 同时杀掉守护进程（防止它重新拉起 gateway）
-    if (process.platform === 'win32') {
-        try {
-            const daemonPidStr = fs_1.default.readFileSync(GATEWAY_DAEMON_PID_FILE, 'utf8').replace(/^\uFEFF/, '').trim();
-            const daemonPid = parseInt(daemonPidStr, 10);
-            if (daemonPid && !isNaN(daemonPid)) {
-                try {
-                    process.kill(daemonPid, 'SIGTERM');
-                }
-                catch { /* ignore */ }
-                await new Promise(r => setTimeout(r, 500));
+        const { stdout } = await execAsync(`powershell -NoProfile -Command "Get-Process -Name '${q(name)}' -ErrorAction SilentlyContinue | ` +
+            `Where-Object { $_.Id -ne ${process.pid} -and $_.Path -ieq '${q(exe)}' } | ` +
+            `ForEach-Object { $_.Id }"`, { timeout: 10000, windowsHide: true });
+        const pids = stdout.split(/\r?\n/)
+            .map(line => parseInt(line.trim(), 10))
+            .filter(n => !isNaN(n) && n !== process.pid);
+        for (const orphan of pids) {
+            try {
+                process.kill(orphan, 'SIGTERM');
+            }
+            catch { /* ignore */ }
+            if (!(await waitForPidExit(orphan, 3000))) {
                 try {
-                    process.kill(daemonPid, 'SIGKILL');
+                    process.kill(orphan, 'SIGKILL');
                 }
                 catch { /* ignore */ }
             }
         }
+        return pids.length;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * 停止 Gateway 用户进程（优雅终止）
+ *
+ * 注意：当 pid 指向当前进程自己时，绝不能使用 process.kill(pid)。
+ *   - Windows 上 Node 的 process.kill 等同 TerminateProcess，无清理机会，
+ *     server.close() / WebSocket / 文件句柄都不会被释放，会导致后续 exe 解锁超时。
+ *   - 因此自杀场景改走 process.emit('SIGTERM')，复用 main.ts 已注册的优雅关闭逻辑，
+ *     并在响应返回后异步退出，避免 HTTP 调用方读不到结果。
+ *
+ * 返回：self 表示停的是当前进程（无法在本进程内校验最终结果），
+ *       stopped 表示已确认目标进程退出。
+ */
+async function stopGatewayProcess() {
+    const pid = getStoredPid();
+    // 先断开守护进程，否则它会在 gateway 退出后立刻把它重新拉起
+    await stopDaemonProcess();
+    // —— 场景 1：要停的就是自己 —— 走优雅退出
+    if (pid && pid === process.pid) {
+        try {
+            fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+        }
         catch { /* ignore */ }
+        // 异步触发，确保当前调用栈（含 HTTP 响应）有机会先返回
+        setTimeout(() => {
+            try {
+                process.emit('SIGTERM');
+            }
+            catch { /* ignore */ }
+            // 兜底：5s 内 SIGTERM handler 没把进程关掉，再强退
+            setTimeout(() => process.exit(0), 5000).unref();
+        }, 100).unref();
+        return { stopped: true, self: true };
+    }
+    // —— 场景 2：停的是别人（CLI 停后台实例 / 孤儿进程）—— 才真正发信号
+    let stopped = true;
+    if (pid && isPidAlive(pid)) {
         try {
-            fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
+            process.kill(pid, 'SIGTERM');
         }
         catch { /* ignore */ }
+        stopped = await waitForPidExit(pid, 5000);
+        if (!stopped) {
+            // 优雅关闭超时，强制终止
+            try {
+                process.kill(pid, 'SIGKILL');
+            }
+            catch { /* ignore */ }
+            stopped = await waitForPidExit(pid, 3000);
+        }
     }
+    try {
+        fs_1.default.unlinkSync(GATEWAY_PID_FILE);
+    }
+    catch { /* ignore */ }
+    // 兜底：清理没被 PID 文件记录到的残留进程
+    await stopGatewayByExePath();
+    return { stopped, self: false };
 }
 /**
  * 写入 Gateway 启动脚本（用户级，不弹出窗口）
@@ -226,8 +329,14 @@ function writeGatewayLauncherScript(exePath, scriptPath, workDir) {
         '# 守护循环：监控进程状态，异常退出则自动重启',
         'while ($true) {',
         '  try {',
-        '    # 每 5 秒检查一次进程是否仍在运行',
-        '    Start-Sleep -Seconds 5',
+        '    # 每 1 秒检查一次：轮询间隔过长会错过 stop 写入的停止标记，导致误重启',
+        '    Start-Sleep -Seconds 1',
+        '',
+        '    # 优先判定停止标记：无论 gateway 是否已退出，主动停止时守护都应该退出',
+        '    if (Test-Path $stopFlag) {',
+        "      Write-Log '检测到停止标记，守护进程退出'",
+        '      break',
+        '    }',
         '',
         '    # 进程已退出',
         '    if ($proc.HasExited) {',
@@ -364,6 +473,11 @@ async function startServiceWindows() {
         return { success: true, message: 'Gateway 已在运行' };
     }
     try {
+        // 清除上一次 stop 可能残留的停止标记，否则新守护会立即退出
+        try {
+            fs_1.default.unlinkSync(GATEWAY_STOP_FLAG_FILE);
+        }
+        catch { /* ignore */ }
         const exe = getGatewayExePath();
         const workDir = path_1.default.dirname(exe);
         if (!fs_1.default.existsSync(GATEWAY_LAUNCHER_FILE)) {
@@ -388,9 +502,15 @@ async function startServiceWindows() {
 }
 async function restartServiceWindows() {
     try {
-        await stopService();
+        const stopResult = await stopService();
+        if (!stopResult.success) {
+            return { success: false, message: `重启失败（停止阶段）: ${stopResult.message}` };
+        }
         await new Promise(r => setTimeout(r, 1000));
-        await startService();
+        const startResult = await startService();
+        if (!startResult.success) {
+            return { success: false, message: `重启失败（启动阶段）: ${startResult.message}` };
+        }
         return { success: true, message: 'Gateway 重启成功' };
     }
     catch (err) {
@@ -399,23 +519,33 @@ async function restartServiceWindows() {
 }
 async function stopServiceWindows() {
     try {
+        if (!isGatewayRunning() && !getDaemonPid()) {
+            return { success: true, message: 'Gateway 未在运行' };
+        }
         // 写入停止标记，告知守护进程这是主动停止，不要重启
         try {
+            fs_1.default.mkdirSync(path_1.default.dirname(GATEWAY_STOP_FLAG_FILE), { recursive: true });
             fs_1.default.writeFileSync(GATEWAY_STOP_FLAG_FILE, '1', 'utf8');
         }
         catch { /* ignore */ }
-        // 给守护进程一点时间检测到标记
-        await new Promise(r => setTimeout(r, 200));
-        await stopGatewayProcess();
-        // 清理停止标记和守护进程 PID 文件
+        const { stopped, self } = await stopGatewayProcess();
+        // 自停场景（HTTP 接口调用）退出发生在本函数返回之后，无法在此校验，
+        // 也不能删停止标记（它要留给守护进程判定主动停止）
+        if (self) {
+            return { success: true, message: 'Gateway 正在退出' };
+        }
+        // 确认退出后才能清理停止标记，否则残留守护会把 gateway 重新拉起
+        if (!stopped) {
+            return { success: false, message: 'Gateway 进程未能终止，请手动结束进程后重试' };
+        }
         try {
             fs_1.default.unlinkSync(GATEWAY_STOP_FLAG_FILE);
         }
         catch { /* ignore */ }
-        try {
-            fs_1.default.unlinkSync(GATEWAY_DAEMON_PID_FILE);
+        // 最终校验：避免在没真正停掉时还报成功
+        if (isGatewayRunning()) {
+            return { success: false, message: 'Gateway 仍在运行，停止失败' };
         }
-        catch { /* ignore */ }
         return { success: true, message: 'Gateway 已停止' };
     }
     catch (err) {
@@ -451,21 +581,21 @@ async function installLinux() {
         if (installed)
             await stopService();
         const execStart = isPkg ? exe : `${exe} ${script}`;
-        const unitContent = `[Unit]
-Description=${exports.SERVICE_DISPLAY_NAME}
-After=network.target
-
-[Service]
-Type=simple
-User=${process.env.USER || 'root'}
-WorkingDirectory=${workDir}
-ExecStart=${execStart}
-Restart=always
-RestartSec=5
-Environment=NODE_ENV=production
-
-[Install]
-WantedBy=multi-user.target
+        const unitContent = `[Unit]
+Description=${exports.SERVICE_DISPLAY_NAME}
+After=network.target
+
+[Service]
+Type=simple
+User=${process.env.USER || 'root'}
+WorkingDirectory=${workDir}
+ExecStart=${execStart}
+Restart=always
+RestartSec=5
+Environment=NODE_ENV=production
+
+[Install]
+WantedBy=multi-user.target
 `;
         await fs_1.default.promises.writeFile('/tmp/myassis-gateway.service', unitContent, 'utf8');
         await execAsync('cp /tmp/myassis-gateway.service /etc/systemd/system/myassis-gateway.service', { timeout: 10000 });

package/dist/services/memory/MemoryManager.js

@@ -38,6 +38,15 @@ const DEFAULT_CONFIG = {
     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)
@@ -103,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()];
@@ -111,29 +123,25 @@ 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, '', toSummarize),
-                ...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;
@@ -141,29 +149,163 @@ class MemoryManager {
         // 边界之前的消息已被摘要取代，其工具调用需通过账本保留
         const omitted = messages.filter((m) => m.createdAt <= boundaryAt);
         if (!this.shouldSummarize(newMessages) || newMessages.length <= keep) {
-            return [
-                this.toSummaryMessage(this.session.lastMessageSummary, boundaryAt, '', omitted),
-                ...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, '', omitted),
-                ...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, '', [...omitted, ...toSummarize]),
-            ...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/session/Session.js

@@ -114,6 +114,8 @@ class Session {
     unreadCount = 0;
     currentMessageId = null;
     abortController = null;
+    /** 后台预压缩的延迟定时器 */
+    precompressionTimer = null;
     toInsertMessages;
     constructor(data) {
         this.id = data.id;
@@ -493,6 +495,59 @@ class Session {
         lines.push('调用时必须传入完整步骤列表，且同一时刻最多一个步骤为 in_progress。');
         return lines.join('\n');
     }
+    /**
+     * 把当前计划推送到 Desktop。
+     *
+     * 用动态 import 获取 webSocketService：WebSocketService 反向依赖本文件的
+     * handleApprovalResponse，静态引入会形成循环依赖。
+     */
+    async notifyPlanUpdate() {
+        try {
+            const { webSocketService } = await Promise.resolve().then(() => __importStar(require('../WebSocketService.js')));
+            webSocketService.sendToUser(String(this.userId), {
+                type: 'plan_updated',
+                payload: {
+                    sessionId: this.id,
+                    agentId: this.agentId,
+                    steps: this.plan,
+                    updatedAt: this.planUpdatedAt,
+                },
+            });
+        }
+        catch (error) {
+            logger.error('推送计划更新失败:', error);
+        }
+    }
+    /**
+     * 构造「收尾时计划未完成」的提醒。
+     *
+     * 模型准备结束回复时，如果计划里还有未完成的步骤，说明它要么漏了同步，
+     * 要么还有事情没做完。返回提醒文案要求它先处理；无需提醒时返回 null。
+     */
+    buildPlanFinalizeReminder() {
+        if (this.plan.length === 0 || this.isPlanCompleted())
+            return null;
+        const unfinished = this.plan.filter(item => item.status !== 'completed');
+        const list = unfinished.map(item => `「${item.step}」`).join('、');
+        return `【计划未完成提醒】你准备结束本轮回复，但计划中仍有 ${unfinished.length} 个步骤未标记完成：${list}。
+`
+            + `请判断：如果这些步骤其实已经做完了，立即调用 updatePlan 把它们全部置为 completed；
+`
+            + `如果确实还没做，请继续完成剩余工作并同步计划状态。不要在计划未收尾的情况下结束回复。`;
+    }
+    /**
+     * 本轮结束时兜底处理未完成的计划。
+     *
+     * 即使提醒过模型，它仍可能不收尾。此时清空计划，避免 Desktop 的
+     * 进度圈永远停留在未完成状态。
+     */
+    async finalizePlanOnComplete() {
+        if (this.plan.length === 0 || this.isPlanCompleted())
+            return;
+        logger.warn(`会话 ${this.id} 结束时计划仍未完成，已自动清除计划以释放进度圈`);
+        this.clearPlan();
+        await this.notifyPlanUpdate();
+    }
     // 清除未读消息数并持久化
     clearUnreadCount() {
         this.unreadCount = 0;
@@ -549,6 +604,8 @@ class Session {
         if (this.isPlanCompleted()) {
             this.clearPlan();
         }
+        // 新请求到来：放弃排队中的预压缩，避免与前台压缩重复调用摘要模型
+        this.abortPrecompression();
         // Add user message
         this.getAbortController();
         this.isGenerating = true;
@@ -641,6 +698,8 @@ class Session {
         let toolRound = 0;
         // 计划模式：距上次调用 updatePlan 已经过的工具轮次，用于在中间过程强制提醒模型同步进度
         let roundsSincePlanUpdate = 0;
+        // 计划模式：收尾时提醒模型补完计划的次数，避免反复提醒导致死循环
+        let planFinalizeNudges = 0;
         // 当前裁剪级别，遇到上下文超限时逐级加重
         let trimLevel = ContextBuilder_js_1.TrimLevel.OldToolPayload;
         /** 判断错误是否为上下文超限 */
@@ -995,7 +1054,25 @@ class Session {
                 return await processModelResponse();
             }
             else {
-                // ========== 没有工具调用，保存消息并结束 ==========
+                // ========== 没有工具调用，准备结束本轮 ==========
+                // 计划模式：计划还没收尾时，先提醒模型补完状态（最多提醒一次，避免死循环）
+                if (planFinalizeNudges < 1) {
+                    const finalizeReminder = this.buildPlanFinalizeReminder();
+                    if (finalizeReminder) {
+                        planFinalizeNudges++;
+                        messages.push({
+                            role: 'assistant',
+                            content: llmResult.content || llmResult.reasoningContent || '',
+                            attachments: []
+                        });
+                        messages.push({
+                            role: 'user',
+                            content: finalizeReminder,
+                            attachments: []
+                        });
+                        return await processModelResponse();
+                    }
+                }
                 if (llmResult.content || llmResult.reasoningContent) {
                     // 分段发送内容，每段约50个字符
                     const chunkSize = 1;
@@ -1052,20 +1129,63 @@ class Session {
                         logger.error('Error closing SSE connection:', e);
                     }
                 }
+                // 计划模式：本轮已结束，若计划仍未完成则兜底清除，避免进度圈残留
+                void this.finalizePlanOnComplete();
                 // 非当前查看的 session，助手回复完成后增加未读计数
                 (0, SessionManager_js_1.getSessionManager)(this.userId).onMessageComplete(this.id);
                 // 只在非 abort 的情况下保存（abort 由 stopGenerating 负责保存）
                 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) {

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/tools/plan.js

@@ -2,7 +2,6 @@
 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'];
@@ -84,15 +83,7 @@ exports.updatePlanTool = {
             }
             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,
-                },
-            });
+            await session.notifyPlanUpdate();
             const completed = steps.filter(s => s.status === 'completed').length;
             return {
                 success: true,

package/package.json

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