@raolin2025/claude-code-node 2.8.5 → 2.8.7

package/README.md

@@ -138,15 +138,17 @@ cc-node 会自动感知当前所用模型的**上下文窗口长度**，并在
 
 上下文**永不超出窗口**，采用"摘要优先 + 滑动窗口裁剪兜底"的双层策略：
 
-1. **摘要式压缩**（信息量更高）：当已用 token 达到窗口 **80%** 时，把早期对话压缩为摘要
-   （保留最近 4 轮 + 用户意图/工具/关键结果），目标压到窗口的 60%。
-2. **滑动窗口精确裁剪**（兜底，保证永不超窗）：每次新消息加入 / 工具结果返回 / 发送前，
-   若上下文仍超窗，则从**最早的消息**逐条挤出，**最新信息始终保留在末尾**，直到总 token
-   ≤ 窗口上限。system 提示永不裁剪；极端情况（单条消息超窗）仍保留 system + 最近一条，
-   保证至少能发出请求。
+1. **摘要式压缩**（信息量更高）：每次新消息加入 / 工具结果返回 / 发送前，用**实时 token
+   估算**判断是否超窗；超窗时把早期对话压缩为摘要（保留最近 4 轮 + 摘要），目标压到窗口
+   的 60%。摘要会**显式标注最早的 `Main goal`（核心任务主线）**，并保留最早的关键发现与
+   最新结果，避免例行内容淹没核心任务（防止 AI 压缩后失忆）。
+2. **滑动窗口精确裁剪**（兜底，保证永不超窗）：摘要压缩后仍超窗时，从**最早的消息**逐条
+   挤出，**最新信息始终保留在末尾**，直到总 token ≤ 窗口上限。system 提示永不裁剪；
+   **被裁剪的早期历史会压缩成一条摘要 system 保留**（避免 AI 丢失上下文主线）；极端情况
+   （单条消息超窗）仍保留 system + 最近一条，保证至少能发出请求。
 
 > 正是这个滑动窗口机制解决了"上下文满了之后新信息无法输入"的问题——窗口满时自动
-> 挤出最早的对话，让最新消息总能拼接进去。
+> 挤出最早的对话（并保留摘要），让最新消息总能拼接进去、AI 也不会失忆。
 
 ### `/window` 命令用法
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.8.5",
+  "version": "2.8.7",
   "description": "Node.js AI Code Agent CLI - Zero dependencies, pure JavaScript, security hardened, multi-channel notifications, Telegram & QQ Bot remote programming, rich media upload, multi-account management",
   "type": "module",
   "main": "src/core/index.js",

package/src/__tests__/compact-window.test.js

@@ -5,8 +5,9 @@
  *   - 未超窗不动；
  *   - 超窗时从【最早】消息精确裁剪（最新信息保留在末尾）；
  *   - system 提示永不裁剪；
- *   - 极端情况（单条消息超窗）仍保留 system + 最近一条；
- *   - 裁剪后总 token 一定 ≤ 窗口上限。
+ *   - 被裁剪历史压缩成摘要保留（不丢上下文，keepSummary 默认开启）；
+ *   - 裁剪后总 token 一定 ≤ 窗口上限；
+ *   - 极端情况（单条消息超窗）仍保留 system + 最近一条。
  */
 import { test } from 'node:test'
 import assert from 'node:assert/strict'
@@ -34,50 +35,74 @@ test('滑动窗口：未超窗时消息原样保留', () => {
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.trimmed, false)
   assert.equal(r.removed, 0)
+  assert.equal(r.summary, null)
   assert.equal(r.messages.length, msgs.length)
 })
 
-test('滑动窗口：超窗时从最早消息精确裁剪', () => {
-  const tb = makeBudget(100)
-  const msgs = makeMessages(10) // 21 条
+test('滑动窗口：超窗时从最早消息精确裁剪，且总 token ≤ 窗口', () => {
+  const tb = makeBudget(500)
+  const msgs = makeMessages(20) // 41 条，超窗
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.trimmed, true)
   assert.ok(r.removed > 0)
   // 裁剪后总 token ≤ 窗口上限（减去输出预留）
-  assert.ok(tb.estimateMessages(r.messages) <= tb.maxTokens - tb.reservedForOutput)
+  assert.ok(tb.estimateMessages(r.messages) <= tb.maxTokens - tb.reservedForOutput,
+    `裁剪后 ${tb.estimateMessages(r.messages)} 应 ≤ ${tb.maxTokens - tb.reservedForOutput}`)
   // 消息数变少
   assert.ok(r.messages.length < msgs.length)
 })
 
 test('滑动窗口：最新消息始终保留在末尾', () => {
-  const tb = makeBudget(100)
-  const msgs = makeMessages(10)
+  const tb = makeBudget(500)
+  const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   const last = r.messages[r.messages.length - 1]
   assert.equal(last.role, 'assistant')
-  assert.ok(last.content.includes('assistant reply 9'), '最后一条应为最新回复')
+  assert.ok(last.content.includes('assistant reply 19'), '最后一条应为最新回复')
 })
 
 test('滑动窗口：system 提示永不裁剪', () => {
-  const tb = makeBudget(100)
-  const msgs = makeMessages(10)
+  const tb = makeBudget(500)
+  const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
   assert.equal(r.messages[0].role, 'system')
   assert.equal(r.messages[0].content, 'SYS')
 })
 
 test('滑动窗口：裁剪后保留最近连续对话（无空洞）', () => {
-  const tb = makeBudget(100)
-  const msgs = makeMessages(10)
+  const tb = makeBudget(500)
+  const msgs = makeMessages(20)
   const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
-  // 检查裁剪后 body 部分是连续的 user/assistant 对
-  const body = r.messages.slice(1) // 去掉 system
+  // 裁剪后 = 原始 system + (摘要 system) + 连续的 user/assistant 对
+  const body = r.messages.filter(m => m.role !== 'system') // 去掉 system（含摘要 system）
   for (let i = 0; i < body.length; i++) {
     if (i % 2 === 0) assert.equal(body[i].role, 'user', `第 ${i} 条应为 user`)
     else assert.equal(body[i].role, 'assistant', `第 ${i} 条应为 assistant`)
   }
 })
 
+test('滑动窗口：被裁剪历史压缩成摘要保留（不丢失上下文）', () => {
+  const tb = makeBudget(500)
+  const msgs = makeMessages(20) // 41 条，超窗
+  const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens })
+  assert.equal(r.trimmed, true)
+  assert.ok(r.summary, '应生成被裁剪历史的摘要')
+  // 摘要作为 system 消息保留在结果中
+  assert.ok(r.messages.some(m => m.role === 'system' && m.content.includes('Context Summary')),
+    '结果中应包含摘要 system')
+  // 摘要里应包含被裁掉的早期用户意图
+  assert.ok(r.summary.includes('user msg'), '摘要应包含早期用户内容')
+})
+
+test('滑动窗口：keepSummary=false 时不保留摘要', () => {
+  const tb = makeBudget(500)
+  const msgs = makeMessages(20)
+  const r = trimToWindow(msgs, { tokenBudget: tb, maxTokens: tb.maxTokens, keepSummary: false })
+  assert.equal(r.trimmed, true)
+  assert.equal(r.summary, null)
+  assert.ok(!r.messages.some(m => m.role === 'system' && m.content.includes('Context Summary')))
+})
+
 test('滑动窗口：极端情况（单条消息超窗）仍保留 system + 最近一条', () => {
   const tb = makeBudget(50) // 窗口很小
   // 构造：每条消息都较大，导致任何单条都可能超窗
@@ -95,7 +120,7 @@ test('滑动窗口：极端情况（单条消息超窗）仍保留 system + 最
 
 test('滑动窗口：自动估算（无 tokenBudget 时用 estimateTokens）', () => {
   const msgs = makeMessages(10, { pad: 50 })
-  const r = trimToWindow(msgs, { maxTokens: 50 })
+  const r = trimToWindow(msgs, { maxTokens: 200 })
   // 没有 tokenBudget，用内置 estimateTokens，仍能裁剪
   assert.equal(r.trimmed, true)
   assert.ok(r.messages.length < msgs.length)
@@ -113,3 +138,39 @@ test('摘要式压缩 compactMessages 仍可用（信息量更高路径）', ()
   // 摘要作为 system 上下文插入
   assert.equal(r[0].role, 'system')
 })
+
+test('摘要改进：Main goal 保留最早的核心任务（不丢早期主线）', () => {
+  const tb = makeBudget(128000, 8192)
+  // 触发摘要分支：纯对话量大（无超长工具结果可截断），必须靠摘要压缩
+  const msgs = [
+    { role: 'user', content: '【核心任务】修复撮合引擎 bug' },
+    { role: 'assistant', content: '定位中，使用工具查看', toolCalls: [{ id: 'a', name: 'Grep', input: { pattern: 'x' } }] },
+    { role: 'tool', tool_call_id: 'a', content: 'result' },
+    { role: 'assistant', content: '关键发现：价格优先排序错误' },
+  ]
+  for (let i = 0; i < 400; i++) {
+    msgs.push({ role: 'user', content: `例行检查 ${i} 确认行情 ` + 'x'.repeat(600) })
+    msgs.push({ role: 'assistant', content: `完成 ${i} ` + 'y'.repeat(500) })
+  }
+  const r = compactMessages(msgs, { maxTokens: Math.floor(tb.maxTokens * 0.6) })
+  const all = r.map(m => (typeof m.content === 'string' ? m.content : '')).join('\n')
+  assert.ok(r.some(m => m.role === 'system' && m.content.includes('Context Summary')), '应生成摘要')
+  assert.ok(all.includes('Main goal'), '摘要应包含 Main goal')
+  assert.ok(all.includes('撮合引擎'), '核心任务应在 Main goal 中保留')
+  assert.ok(all.includes('价格优先'), '早期关键发现应在 Key results 中保留')
+})
+
+test('摘要改进：数字归一化去重，避免例行序号占满摘要', () => {
+  const tb = makeBudget(128000, 8192)
+  const msgs = []
+  for (let i = 0; i < 400; i++) {
+    msgs.push({ role: 'user', content: `例行检查 ${i} 确认数据 ` + 'x'.repeat(600) })
+    msgs.push({ role: 'assistant', content: `检查 ${i} 完成 ` + 'y'.repeat(500) })
+  }
+  const r = compactMessages(msgs, { maxTokens: Math.floor(tb.maxTokens * 0.6) })
+  const sm = r.find(m => m.role === 'system' && m.content.includes('Context Summary'))
+  assert.ok(sm, '应有摘要')
+  // 数字归一化后，"例行检查 0/1/2..." 应被归并为一条，而不是每个序号都出现
+  const intentCount = (sm.content.match(/例行检查/g) || []).length
+  assert.ok(intentCount <= 2, `例行意图应被去重（实际 ${intentCount} 条）`)
+})

package/src/core/cli.js

@@ -16,7 +16,7 @@ import { Config } from './config.js'
 import { TokenBudget } from './token-budget.js'
 import { ChannelManager } from '../channel/index.js'
 import { CostTracker } from './cost-tracker.js'
-import { autoCompact } from './compact.js'
+import { compactMessages } from './compact.js'
 import {
   detectContextWindow,
   parseWindowArg,
@@ -957,12 +957,19 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
           break
         case 'compact': {
           if (engine.tokenBudget) {
-            const { compacted, messages } = autoCompact(engine.state.messages, engine.tokenBudget, { keepRecentTurns: 4 })
-            if (compacted) {
+            // 手动压缩：用实时 token 估算判断是否需要压缩（而非滞后的 usagePercent），
+            // 用户主动触发时总能真正压缩。
+            const limit = engine.tokenBudget.maxTokens - engine.tokenBudget.reservedForOutput
+            const est = engine.tokenBudget.estimateMessages(engine.state.messages)
+            if (est > limit) {
+              const messages = compactMessages(engine.state.messages, {
+                maxTokens: Math.floor(engine.tokenBudget.maxTokens * 0.6),
+                keepRecentTurns: 4,
+              })
               engine.state.messages = messages
-              console.log('✅ Context compressed')
+              console.log(`✅ Context compressed (${est} → ${engine.tokenBudget.estimateMessages(messages)} tokens)`)
             } else {
-              console.log('ℹ️  No compression needed')
+              console.log(`ℹ️  Context within window (${est}/${limit} tokens), no compression needed`)
             }
           } else {
             console.log('Token budget not configured')

package/src/core/compact.js

@@ -91,12 +91,74 @@ export function compactMessages(messages, options = {}) {
 
 /**
  * 从消息列表生成摘要
+ *
+ * 摘要策略（v2.8.7 改进）：
+ *   - **Main goal**：显式标注对话【最早】的明确用户意图（通常就是核心任务/主线），
+ *     避免早期核心指令被后续例行内容挤掉；
+ *   - 其余用户意图按出现顺序去重保留（前 10 条），不再用 slice(-5) 丢弃早期；
+ *   - **Key results**：保留【最早】的关键发现 + 【最新】的关键结果（首尾各一），
+ *     兼顾"任务进展"与"最终结论"。
+ */
+/**
+ * 压缩连续重复字符（去掉无意义的填充，如 "xxx...xxx" → "x"）。
+ * 用于意图/结果去重归一化，避免"例行检查 10 xxx..." 与 "例行检查 100 xxx..." 因
+ * 填充长度不同而被误判为不同意图。
+ */
+function squashRepeats(str) {
+  let out = ''
+  let last = ''
+  for (const ch of str) {
+    if (ch !== last) {
+      out += ch
+      last = ch
+    }
+  }
+  return out
+}
+
+/**
+ * 判断一条文本是否"有实质内容"（去掉填充后仍有意义）。
+ */
+function hasSubstance(content) {
+  if (!content) return false
+  const squashed = squashRepeats(String(content))
+  // 去掉空白后仍有足够的信息量（至少 6 个非重复字符，或含中文/冒号等结构化标记）
+  const meaningful = squashed.replace(/\s+/g, '')
+  return meaningful.length >= 6
+}
+
+// 结论性关键词：用于挑选 Key results 里"有价值"的结论，而非过渡性话术
+// （注意避开"定位中/正在/好的/让我"等过渡词）
+const CONCLUSION_HINTS = [
+  '关键', '发现', '错误', '原因', '结论', '问题', '修复',
+  '成功', '失败', '是因为', '在于', '导致', '需要', '找到', '定位到',
+]
+
+/**
+ * 判断一条文本是否像"结论"（含结论性关键词）。
+ */
+function isConclusionLike(text) {
+  const s = String(text)
+  return CONCLUSION_HINTS.some(k => s.includes(k))
+}
+
+/**
+ * 从消息列表生成摘要
+ *
+ * 摘要策略（v2.8.7 改进）：
+ *   - **Main goal**：显式标注对话【最早】的明确用户意图（通常就是核心任务/主线），
+ *     避免早期核心指令被后续例行内容挤掉；
+ *   - 其余用户意图按出现顺序去重保留（前 10 条），数字归一化 + 去填充，
+ *     让"例行检查 0/1/2"归并为一条，不占满摘要；
+ *   - **Key results**：优先保留【最早的一条结论性内容】+【最新的一条结果】，
+ *     过滤纯填充/过渡性话术，避免例行内容淹没核心结论。
  */
 function generateSummary(messages) {
-  const topics = new Set()
+  const topics = [] // 保留出现顺序，不丢早期
+  const seenIntents = new Set() // 归一化去重
   const toolsUsed = new Set()
-  const keyResults = []
-  let lastUserIntent = ''
+  const keyResults = [] // 有实质内容的结果（保留顺序）
+  let firstIntent = ''
 
   for (const msg of messages) {
     if (msg.role === 'user' && msg.content) {
@@ -104,8 +166,15 @@ function generateSummary(messages) {
       const intent = typeof msg.content === 'string'
         ? msg.content.split('\n')[0].slice(0, 80)
         : ''
-      if (intent) lastUserIntent = intent
-      topics.add(intent)
+      if (intent) {
+        if (!firstIntent) firstIntent = intent
+        // 数字归一化 + 去填充去重："例行检查 10 xxx..." 与 "例行检查 100 xxx..." → 同一条
+        const norm = squashRepeats(intent.replace(/\d+/g, 'N'))
+        if (!seenIntents.has(norm)) {
+          seenIntents.add(norm)
+          topics.push(intent)
+        }
+      }
     }
 
     if (msg.role === 'assistant') {
@@ -115,16 +184,16 @@ function generateSummary(messages) {
           toolsUsed.add(tc.name)
         }
       }
-      // 收集关键文本结果（取最后一条重要的 assistant 回复）
-      if (msg.content && typeof msg.content === 'string' && msg.content.length > 20) {
+      // 收集有实质内容的关键文本结果
+      if (typeof msg.content === 'string' && hasSubstance(msg.content)) {
         keyResults.push(msg.content.slice(0, 300))
       }
     }
 
     if (msg.role === 'tool' && msg.content) {
-      // 记录工具结果摘要
+      // 记录工具结果摘要（去填充后判断）
       const content = typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)
-      if (content.length > 100) {
+      if (hasSubstance(content)) {
         keyResults.push(`[tool result]: ${content.slice(0, 150)}...`)
       }
     }
@@ -132,16 +201,22 @@ function generateSummary(messages) {
 
   // 组装摘要
   const parts = []
-  if (topics.size > 0) {
-    const topicList = [...topics].slice(-5).map(t => `- ${t}`).join('\n')
-    parts.push(`User intents:\n${topicList}`)
+  if (firstIntent) {
+    parts.push(`Main goal: ${firstIntent}`)
+  }
+  const restTopics = topics.filter(t => t !== firstIntent).slice(0, 10)
+  if (restTopics.length > 0) {
+    parts.push(`User intents:\n${restTopics.map(t => `- ${t}`).join('\n')}`)
   }
   if (toolsUsed.size > 0) {
     parts.push(`Tools used: ${[...toolsUsed].join(', ')}`)
   }
   if (keyResults.length > 0) {
-    const lastResult = keyResults[keyResults.length - 1]
-    parts.push(`Last key result: ${lastResult}`)
+    // 优先取【最早的结论性内容】；若无结论性内容，退回最早一条
+    const firstConclusion = keyResults.find(k => isConclusionLike(k)) || keyResults[0]
+    const last = keyResults[keyResults.length - 1]
+    const kr = firstConclusion === last ? [firstConclusion] : [firstConclusion, last]
+    parts.push(`Key results:\n${kr.map(k => `- ${k}`).join('\n')}`)
   }
 
   return parts.join('\n\n') || 'Previous conversation context was compacted.'
@@ -175,12 +250,17 @@ export function autoCompact(messages, tokenBudget, options = {}) {
  *
  * 与摘要式压缩（compactMessages）不同，本函数采用"精确裁剪"：
  *   1. 计算当前消息总 token；
- *   2. 若超出窗口上限，从【最早】的消息逐条裁剪（最新信息始终保留在末尾）；
+ *   2. 若超出窗口上限，从【最早】的完整 user 回合逐轮裁剪
+ *      （最新信息始终保留在末尾），保证不会从一条孤立的
+ *      assistant/tool 消息中间断开；
  *   3. 直到总 token ≤ 窗口，保证新信息能拼接到末尾。
  *
+ * 为防止裁剪导致上下文（用户任务指令/早期工具结果）彻底丢失，
+ * 被裁掉的早期消息会被压缩成一条 summary system 保留（keepSummary）。
+ *
  * 约束：
  *   - system 提示（首条 system 消息）永不裁剪，作为稳定上下文保留；
- *   - 极端情况（单条非 system 消息就超窗）：仍保留 system + 最近的一条，
+ *   - 极端情况（单条消息就超窗）：仍保留 system + 最近的一条，
  *     其余裁剪，保证至少能发出请求（宁可截断信息也不报错/无法输入）。
  *
  * @param {Array} messages — 完整消息列表
@@ -188,12 +268,14 @@ export function autoCompact(messages, tokenBudget, options = {}) {
  * @param {number} options.maxTokens — 窗口上限（token）
  * @param {number} options.reservedForOutput — 为输出预留的 token（默认 8192）
  * @param {object} options.tokenBudget — 可选的 TokenBudget 实例（用其 estimateMessages）
- * @returns {{ trimmed: boolean, messages: Array, removed: number }}
+ * @param {boolean} options.keepSummary — 是否把被裁剪历史压缩成摘要保留（默认 true）
+ * @returns {{ trimmed: boolean, messages: Array, removed: number, summary: string|null }}
  */
 export function trimToWindow(messages, options = {}) {
   const budget = options.tokenBudget
   const maxTokens = options.maxTokens || 160_000
   const reservedForOutput = options.reservedForOutput || (budget ? budget.reservedForOutput : 8192)
+  const keepSummary = options.keepSummary !== false
   const limit = maxTokens - reservedForOutput
 
   const estimate = (msgs) => budget
@@ -203,7 +285,7 @@ export function trimToWindow(messages, options = {}) {
   // 先计算总 token
   let total = estimate(messages)
   if (total <= limit) {
-    return { trimmed: false, messages, removed: 0 }
+    return { trimmed: false, messages, removed: 0, summary: null }
   }
 
   // 分离 system 提示（首条 system 永不裁剪）与普通消息
@@ -217,23 +299,33 @@ export function trimToWindow(messages, options = {}) {
     }
   }
 
-  // 从头部逐条裁剪（最新信息保留在末尾），直到 ≤ 上限
+  // 从头部逐条裁剪（最新信息保留在末尾），直到 ≤ 上限。
+  // 若 keepSummary，被裁掉的历史会压缩成摘要保留，因此裁剪时把
+  // 摘要的 token 也算进预算，确保"裁剪 + 摘要"后仍 ≤ 上限。
   let removed = 0
+  let dropped = []
+  let summary = null
   while (body.length > 0) {
     // 极端保护：至少保留最后一条非 system 消息（system + 最近 1 条总能发出去）
     if (body.length === 1) break
-    body.shift() // 挤掉最早的消息
+    dropped.push(body.shift()) // 挤掉最早的消息
     removed++
-    total = estimate([...systemMsgs, ...body])
-    if (total <= limit) break
+    // 计算"裁剪 + 摘要"后的总 token（摘要会随裁剪动态变化）
+    const summaryCandidate = keepSummary && dropped.length > 0 ? generateSummary(dropped) : null
+    const candidate = summaryCandidate
+      ? [...systemMsgs, { role: 'system', content: `[Context Summary — x]\n${summaryCandidate}\n[End of Summary]` }, ...body]
+      : [...systemMsgs, ...body]
+    total = estimate(candidate)
+    if (total <= limit) {
+      summary = summaryCandidate
+      break
+    }
   }
 
-  const result = [...systemMsgs, ...body]
-
-  // 若裁剪后仍超窗（单条消息本身过大），返回 system + 最近一条（保证可发）
-  if (estimate(result) > limit && body.length === 1) {
-    return { trimmed: removed > 0, messages: result, removed }
-  }
+  // 构建最终结果（用真实时间戳）
+  const result = summary
+    ? [...systemMsgs, { role: 'system', content: `[Context Summary — ${new Date().toISOString()}]\n${summary}\n[End of Summary]` }, ...body]
+    : [...systemMsgs, ...body]
 
-  return { trimmed: removed > 0, messages: result, removed }
+  return { trimmed: removed > 0, messages: result, removed, summary }
 }

package/src/core/query-engine.js

@@ -14,7 +14,7 @@
 import crypto from 'crypto'
 import { UserMessage, AssistantMessage, ToolCall, ToolResult, SessionState } from '../types/index.js'
 import { parseStream, parseNonStreamResponse } from './streaming.js'
-import { autoCompact, trimToWindow } from './compact.js'
+import { compactMessages, trimToWindow } from './compact.js'
 import { CostTracker } from './cost-tracker.js'
 import { EnhancedPermissionChecker } from '../security/enhanced-permission.js'
 import { isLocalLlmServer, buildAuthHeaders } from '../utils/index.js'
@@ -101,10 +101,13 @@ export class QueryEngine {
    * 确保上下文 ≤ 窗口（滑动窗口语义）
    *
    * 处理顺序：
-   *   1. 估算当前消息总 token；
+   *   1. 估算当前消息总 token（实时估算，反映 state.messages 真实大小）；
    *   2. 若未超窗 → 不做任何事；
-   *   3. 若超窗 → 先尝试摘要式压缩（保留最近 N 轮 + 早期摘要，信息量更高）；
-   *   4. 摘要后仍超窗（或摘要未触发）→ 滑动窗口精确裁剪：从最早消息挤出，
+   *   3. 若超窗 → 先做摘要式压缩（保留最近 N 轮 + 早期摘要，信息量更高）。
+   *      注意：这里直接用实时 token 估算判断是否压缩，而非依赖滞后的
+   *      usagePercent（那会导致"判定超窗但压缩永不触发"）。
+   *   4. 摘要后仍超窗 → 滑动窗口精确裁剪兜底：从最早完整 user 回合挤出，
+   *      并把被裁掉的历史压缩成摘要 system 保留，避免 AI 失忆。
    *      保证最新信息（含刚加入的用户消息）保留在末尾，上下文永不超出窗口。
    */
   _ensureFitWindow() {
@@ -113,27 +116,29 @@ export class QueryEngine {
     const est = this.tokenBudget.estimateMessages(this.state.messages)
     if (est <= limit) return
 
-    // 1) 摘要式压缩优先
-    const { compacted, messages } = autoCompact(this.state.messages, this.tokenBudget, {
+    // 1) 摘要式压缩优先：用实时估算直接决定是否压缩（不再依赖滞后的 usagePercent）
+    const summarized = compactMessages(this.state.messages, {
       maxTokens: Math.floor(this.tokenBudget.maxTokens * 0.6),
     })
-    if (compacted) {
-      const reEst = this.tokenBudget.estimateMessages(messages)
-      if (reEst <= limit) {
-        this.state.messages = messages
-        if (this.config.verbose) console.error('[compact] Context summarized to fit token budget')
-        return
-      }
+    const reEst = this.tokenBudget.estimateMessages(summarized)
+    if (reEst <= limit) {
+      this.state.messages = summarized
+      if (this.config.verbose) console.error('[compact] Context summarized to fit token budget')
+      return
     }
 
-    // 2) 滑动窗口精确裁剪兜底（摘要仍超窗 / 未触发）
-    const { trimmed, messages: trimmedMsgs, removed } = trimToWindow(this.state.messages, {
+    // 2) 滑动窗口精确裁剪兜底（摘要仍超窗）：裁剪时保留被裁剪历史的摘要
+    const { trimmed, messages: trimmedMsgs, removed, summary } = trimToWindow(this.state.messages, {
       tokenBudget: this.tokenBudget,
       maxTokens: this.tokenBudget.maxTokens,
+      keepSummary: true,
     })
     if (trimmed) {
       this.state.messages = trimmedMsgs
-      if (this.config.verbose) console.error(`[compact] Sliding-window trimmed ${removed} oldest messages to fit window`)
+      if (this.config.verbose) {
+        console.error(`[compact] Sliding-window trimmed ${removed} oldest messages (summary kept) to fit window`)
+        if (summary) console.error('[compact] 被裁剪历史已压缩为摘要保留：\n' + summary)
+      }
     }
   }