xbot 上下文管理 Phase 2 优化设计

// OffloadConfig Layer 1 配置
type OffloadConfig struct {
    MaxResultTokens int    // 单条 tool result 触发 offload 的 token 阈值（默认 2000）
    MaxResultBytes  int    // 单条 tool result 触发 offload 的字节阈值（默认 10240）
    StoreDir        string // offload 存储目录（默认 {DataDir}/offload_store/）
}

// OffloadedResult 已 offload 的 tool result 的元数据
type OffloadedResult struct {
    ID        string    // 唯一 ID（uuid）
    ToolName  string    // 工具名称
    Args      string    // 工具参数（截断）
    FilePath  string    // 落盘文件路径
    TokenSize int       // 原始 token 数
    Timestamp time.Time // offload 时间
    Summary   string    // 摘要（规则提取同步生成 + 可选 LLM 增强）
}

// offload_recall 工具定义
// 注册方式：在 tools/ 目录新增 offload_recall.go，通过 Tools.Registry 注册
type OffloadRecallArgs struct {
    ID string `json:"id" jsonschema:"description=offload 条目 ID（如 offload_abc123）"`
}

// 执行逻辑：
// 1. 从 offload_store/{session_key}/index.json 查找 ID 对应的文件路径
// 2. 读取完整 tool result 内容
// 3. 如果内容仍然过大（> MaxResultTokens），返回截断版本 + 原始文件路径
// 4. 返回格式：
//    "📂 [offload recall: {id}] {tool_name}({args})\n{完整内容或截断版本}"

// 与 HookChain 集成：
// - 无需特殊 Hook，作为普通工具注册到 Agent 的 Tools 列表中
// - LLM 在上下文中看到 [offload:xxx] 标记时，自然会使用 offload_recall 工具获取详情
// - 依赖 Issue #98 的 Tool Hook 机制（PreToolUse/PostToolUse）来拦截大结果

// EvictPolicy 驱逐策略
type EvictPolicy struct {
    // 保留最近 N 组完整 tool call/result
    KeepRecentGroups int // 默认 3（与 thinTail 对齐）

    // 信息密度评分：决定驱逐优先级
    // 低密度（大块代码转储、重复 grep 结果）优先驱逐
    // 高密度（错误信息、决策记录、小但关键的代码片段）最后驱逐
    DensityScorer func(msg llm.ChatMessage) float64
}

// defaultDensityScorer 默认信息密度评分函数
func defaultDensityScorer(msg llm.ChatMessage) float64 {
    score := 0.0
    content := msg.Content

    // 高密度信号（加分）
    if containsErrorPattern(content)    { score += 3.0 } // 错误信息
    if containsDecisionPattern(content) { score += 2.5 } // 决策记录
    if containsFilePath(content)        { score += 1.0 } // 文件路径引用
    if len([]rune(content)) < 500      { score += 1.5 } // 短内容天然密度高

    // 低密度信号（减分）
    if isLargeCodeDump(content)         { score -= 2.0 } // 大段代码转储
    if isRepetitiveGrepResult(content)  { score -= 1.5 } // 重复 grep 结果
    if msg.Role == "tool" && len([]rune(content)) > 3000 { score -= 2.0 }

    return score
}

// EvictCompactPipeline 分层压缩流水线
// 注：Layer 1 (Offload) 在 execOne 后立即触发，不在此 Pipeline 中编排
// Pipeline 仅编排 Layer 2 (Evict) 和 Layer 3 (Compact)
type EvictCompactPipeline struct {
    evictor  *Evictor           // Layer 2
    compFunc CompressFunc       // Layer 3（Phase 1 的 compressContext）
    quality  *QualityEvaluator  // 质量评估（方向四）
}

// Execute 执行压缩流水线，按需触发，不一定每层都执行
func (p *EvictCompactPipeline) Execute(ctx context.Context, 
    messages []llm.ChatMessage, 
    trigger TriggerInfo,
    client llm.LLM, model string) (*CompressResult, error) {
    
    currentTokens, _ := llm.CountMessagesTokens(messages, model)
    threshold := calculateDynamicThreshold(trigger)
    
    // 未达到 Evict 阈值（动态阈值的 80%），不需要压缩
    if float64(currentTokens) / float64(trigger.MaxTokens) < threshold * 0.8 {
        return nil, nil
    }
    
    // Layer 2: Evict
    evicted := p.evictor.Evict(messages, threshold * 0.7)
    evictTokens, _ := llm.CountMessagesTokens(evicted, model)
    
    // Layer 3: Compact（如果 Evict 后仍超阈值）
    var result *CompressResult
    if float64(evictTokens) / float64(trigger.MaxTokens) >= threshold {
        result, _ = p.compFunc(ctx, evicted, client, model)
    } else {
        // Evict 后已足够，直接构建双视图
        result = buildCompressResultFromMessages(evicted)
    }
    
    return result, nil
}

{
  "session_key": "feishu:oc_abc123",
  "entries": [
    {
      "id": "offload_abc123",
      "tool_name": "Read",
      "args": "{\"path\":\"main.go\"}",
      "file": "offload_abc123.json",
      "token_size": 5234,
      "created_at": "2026-03-19T01:00:00Z",
      "summary": "main.go 入口文件，定义 Agent 结构体..."
    }
  ]
}

// TriggerInfo 压缩触发所需的上下文信息
type TriggerInfo struct {
    // 基础信息
    MaxTokens    int       // 最大上下文 token 数
    CurrentTokens int      // 当前上下文 token 数
    
    // 任务阶段信息
    IterationCount int     // 当前 Run() 循环迭代次数
    ToolCallCount  int     // 本次 Run() 的工具调用总次数
    IsFirstUserMsg bool    // 是否是本次用户消息的第一轮迭代
    
    // 增长速率信息
    TokenHistory   []int   // 最近 N 次迭代的 token 数快照（滑窗）
    GrowthRate     float64 // 近期 token 增长速率（tokens/iteration）
    
    // 工具模式信息
    RecentTools    []string // 最近 5 次工具调用名称
    ToolPattern    ToolCallPattern // 识别出的工具调用模式
}

// ToolCallPattern 工具调用模式
type ToolCallPattern int

const (
    PatternConversation ToolCallPattern = iota // 纯对话（无工具调用）
    PatternReadHeavy                           // 读密集（大量 Read/Grep/Glob）
    PatternWriteHeavy                          // 写密集（大量 Edit/Shell 写操作）
    PatternMixed                               // 混合模式
    PatternSubAgent                            // SubAgent 调用
)

// calculateDynamicThreshold 计算动态压缩阈值
// 返回值范围 [0.5, 0.85]，Claude Code 固定为 0.64-0.75
func calculateDynamicThreshold(info TriggerInfo) float64 {
    // 基础阈值
    baseThreshold := 0.70
    
    // === 因子 1: 任务阶段调节 ===
    stageFactor := 1.0
    switch {
    case info.IterationCount <= 3:
        // 信息积累期：宽容阈值，允许更多空间
        stageFactor = 0.85
    case info.IterationCount <= 10:
        // 活跃工作期：标准阈值
        stageFactor = 0.70
    case info.ToolCallCount > 20:
        // 长任务执行期：开始收窄
        stageFactor = 0.65
    default:
        stageFactor = 0.70
    }
    
    // === 因子 2: 增长速率预测 ===
    growthFactor := 1.0
    if info.GrowthRate > 0 {
        // 预测达到 90% 还需要多少轮
        remainingTokens := float64(info.MaxTokens*9/10 - info.CurrentTokens)
        iterationsToFull := remainingTokens / info.GrowthRate
        switch {
        case iterationsToFull < 2:
            // 即将爆满，立即触发（降低阈值）
            growthFactor = 0.50
        case iterationsToFull < 5:
            // 快速增长，提前触发
            growthFactor = 0.60
        case iterationsToFull > 15:
            // 增长缓慢，放宽阈值
            growthFactor = 0.80
        }
    }
    
    // === 因子 3: 工具模式调节 ===
    patternFactor := 1.0
    switch info.ToolPattern {
    case PatternReadHeavy:
        // 读密集：大量文件内容涌入，需要更积极的压缩
        if isScanningPhase(info.RecentTools) {
            patternFactor = 0.60 // 扫描阶段，积极压缩
        } else {
            patternFactor = 0.65
        }
    case PatternWriteHeavy:
        // 写密集：编辑操作通常结果较小，不需要太积极
        patternFactor = 0.75
    case PatternSubAgent:
        // SubAgent 返回结果可能较大，适当提前
        patternFactor = 0.65
    case PatternConversation:
        // 纯对话：增长缓慢，放宽
        patternFactor = 0.80
    case PatternMixed:
        patternFactor = 0.70
    }
    
    // === 综合计算 ===
    // 取各因子的最小值（最保守的策略获胜）
    dynamicThreshold := min(baseThreshold, stageFactor, growthFactor, patternFactor)
    
    // 限制范围
    dynamicThreshold = clamp(dynamicThreshold, 0.50, 0.85)
    
    return dynamicThreshold
}

func clamp(v, min, max float64) float64 {
    if v < min { return min }
    if v > max { return max }
    return v
}

// TokenGrowthTracker token 增长速率追踪器
// 生命周期：存储在 Agent 结构体中，按 session key 索引
//   Agent.growthTrackers map[string]*TokenGrowthTracker
// 每次 Run() 开始时通过 sessionKey 获取或创建，跨 Run() 持久化
// /new 命令时清理对应 session 的 tracker
type TokenGrowthTracker struct {
    window   []tokenSnapshot // 滑动窗口
    maxSize  int             // 窗口大小（默认 10）
}

type tokenSnapshot struct {
    iteration int
    tokens    int
    timestamp time.Time
}

// Record 记录一次 token 快照
func (t *TokenGrowthTracker) Record(iteration int, tokens int) {
    t.window = append(t.window, tokenSnapshot{
        iteration: iteration,
        tokens:    tokens,
        timestamp: time.Now(),
    })
    if len(t.window) > t.maxSize {
        t.window = t.window[1:]
    }
}

// GrowthRate 计算 token 增长速率（tokens/iteration）
// 使用加权线性回归，近期数据权重更高
func (t *TokenGrowthTracker) GrowthRate() float64 {
    if len(t.window) < 2 {
        return 0
    }
    
    // 加权线性回归
    var sumX, sumY, sumXY, sumX2, sumW float64
    n := len(t.window)
    
    for i, snap := range t.window {
        w := float64(i+1) / float64(n) // 近期权重更高
        x := float64(snap.iteration)
        y := float64(snap.tokens)
        sumW += w
        sumX += w * x
        sumY += w * y
        sumXY += w * x * y
        sumX2 += w * x * x
    }
    
    // 斜率 = 增长速率
    slope := (sumW*sumXY - sumX*sumY) / (sumW*sumX2 - sumX*sumX)
    return slope
}

// IsExponentialGrowth 检测是否指数增长
// 指数增长意味着即将爆满，需要立即触发压缩
func (t *TokenGrowthTracker) IsExponentialGrowth() bool {
    if len(t.window) < 4 {
        return false
    }
    
    // 计算相邻增长的比率
    var ratios []float64
    for i := 1; i < len(t.window); i++ {
        delta := t.window[i].tokens - t.window[i-1].tokens
        if delta > 0 && t.window[i-1].tokens > 0 {
            ratios = append(ratios, float64(delta)/float64(t.window[i-1].tokens))
        }
    }
    
    if len(ratios) < 2 {
        return false
    }
    
    // 如果增长率在持续增大（加速增长），判定为指数增长
    accelerating := true
    for i := 1; i < len(ratios); i++ {
        if ratios[i] <= ratios[i-1] {
            accelerating = false
            break
        }
    }
    
    return accelerating
}

// Snapshots 返回当前窗口快照（供 TriggerInfo.TokenHistory 使用）
func (t *TokenGrowthTracker) Snapshots() []int {
    result := make([]int, len(t.window))
    for i, snap := range t.window {
        result[i] = snap.tokens
    }
    return result
}

// CompressCooldown 压缩冷却管理器
type CompressCooldown struct {
    lastCompressIteration int  // 上次触发压缩时的迭代计数
    cooldownIterations    int  // 冷却轮数（默认 3）
}

// ShouldTrigger 判断是否应该触发压缩
// 返回 false 表示处于冷却期，应跳过本次压缩
func (c *CompressCooldown) ShouldTrigger(currentIteration int) bool {
    if c.lastCompressIteration == 0 {
        return true // 从未压缩过
    }
    return (currentIteration - c.lastCompressIteration) >= c.cooldownIterations
}

// RecordCompress 记录一次压缩触发
func (c *CompressCooldown) RecordCompress(iteration int) {
    c.lastCompressIteration = iteration
}

// DetectToolPattern 检测当前工具调用模式
func DetectToolPattern(recentTools []string) ToolCallPattern {
    if len(recentTools) == 0 {
        return PatternConversation
    }
    
    readTools := map[string]bool{"Read": true, "Grep": true, "Glob": true, "WebSearch": true}
    writeTools := map[string]bool{"Edit": true, "Shell": true, "Write": true, "DownloadFile": true}
    
    readCount, writeCount, subAgentCount := 0, 0, 0
    for _, t := range recentTools {
        if readTools[t] { readCount++ }
        if writeTools[t] { writeCount++ }
        if t == "SubAgent" { subAgentCount++ }
    }
    
    total := len(recentTools)
    
    switch {
    case subAgentCount > total/2:
        return PatternSubAgent
    case readCount > total*3/4 && writeCount == 0:
        return PatternReadHeavy
    case writeCount > total/2:
        return PatternWriteHeavy
    case readCount > 0 && writeCount > 0:
        return PatternMixed
    default:
        return PatternConversation
    }
}

// isScanningPhase 判断是否处于代码扫描阶段
// 扫描阶段的特征：最近多次工具调用都是读取类，没有任何写入操作
func isScanningPhase(recentTools []string) bool {
    if len(recentTools) < 3 {
        return false
    }
    
    writeTools := map[string]bool{"Edit": true, "Shell": true, "Write": true}
    
    for _, t := range recentTools {
        if writeTools[t] {
            return false // 发现写入操作，不是扫描阶段
        }
    }
    
    return true // 所有最近工具调用都是读取类
}

// Phase 2 增强版 maybeCompress（伪代码，展示修改点）
// recentToolCalls 从 toolsUsed []string 中取最近 N 条
//   func recentToolCalls(toolsUsed []string, n int) []string {
//       if len(toolsUsed) < n { n = len(toolsUsed) }
//       return toolsUsed[len(toolsUsed)-n:]
//   }

maybeCompress := func() {
    cc := cfg.AutoCompress
    if cc == nil || len(messages) <= 3 {
        return
    }
    
    // === Phase 2 新增：压缩冷却检查 ===
    cooldown := a.getCooldown(sessionKey) // 从 Agent.cooldowns map 中获取
    if !cooldown.ShouldTrigger(i) {
        growthTracker.Record(i, totalTokens) // 仍然记录快照
        return
    }
    
    // === Phase 2 新增：采集触发信息 ===
    currentTokens, _ := llm.CountMessagesTokens(messages, cfg.Model)
    toolDefs := cfg.Tools.AsDefinitionsForSession(sessionKey)
    toolTokens, _ := llm.CountToolsTokens(toolDefs, cfg.Model)
    totalTokens := currentTokens + toolTokens
    
    // growthTracker 来自 Agent.growthTrackers[sessionKey]
    // 生命周期：存储在 Agent 结构体中（map[string]*TokenGrowthTracker）
    // /new 时通过 delete(Agent.growthTrackers, sessionKey) 清理
    triggerInfo := TriggerInfo{
        MaxTokens:      cc.MaxContextTokens,
        CurrentTokens:  totalTokens,
        IterationCount: i,
        ToolCallCount:  len(toolsUsed),
        IsFirstUserMsg: i == 0,
        TokenHistory:   growthTracker.Snapshots(),
        GrowthRate:     growthTracker.GrowthRate(),
        RecentTools:    recentToolCalls(toolsUsed, 5), // 取最近 5 条工具调用
        ToolPattern:    DetectToolPattern(recentToolCalls(toolsUsed, 5)),
    }
    
    // === Phase 2 新增：动态阈值 ===
    dynamicThreshold := calculateDynamicThreshold(triggerInfo)
    threshold := int(float64(cc.MaxContextTokens) * dynamicThreshold)
    
    if totalTokens < threshold {
        // 记录 token 快照（用于增长速率追踪）
        growthTracker.Record(i, totalTokens)
        return
    }
    
    // === Phase 2 新增：指数增长紧急触发 ===
    if growthTracker.IsExponentialGrowth() {
        log.Ctx(ctx).Warn("Exponential token growth detected, forcing early compression")
        threshold = int(float64(cc.MaxContextTokens) * 0.50)
    }
    
    // 记录冷却
    cooldown.RecordCompress(i)
    
    // 执行压缩（复用 Phase 1 逻辑）
    // ... 后续不变 ...
}

// TopicDetector 话题检测器
type TopicDetector struct {
    // 话题切换判定参数
    CosineThreshold float64 // 余弦相似度阈值（默认 0.3，低于此值认为话题切换）
    MinSegmentSize  int     // 最小片段长度（默认 3 条消息，避免碎片化）
}

// TopicSegment 话题片段
type TopicSegment struct {
    ID          string             // 片段 ID
    StartIdx    int                // 起始消息索引（在 session 中的位置）
    EndIdx      int                // 结束消息索引
    MessageCount int               // 消息数
    Keywords    []string           // 提取的关键词（用于标记）
    Summary     string             // 压缩后的摘要（仅已压缩的片段有值）
    IsCurrent   bool               // 是否是当前活跃话题
}

// Detect 检测话题边界
// 输入：session 中的 user/assistant 消息列表
// 输出：话题片段列表
func (d *TopicDetector) Detect(messages []llm.ChatMessage) []TopicSegment {
    if len(messages) < d.MinSegmentSize*2 {
        return []TopicSegment{{ID: "topic_0", StartIdx: 0, EndIdx: len(messages) - 1, IsCurrent: true}}
    }
    
    // 步骤 1: 将消息按"对话轮次"分组（一轮 = user + assistant）
    turns := groupIntoTurns(messages)
    
    // 步骤 2: 为每个轮次提取特征向量
    // 使用轻量级特征（关键词 TF-IDF 或简单词袋），支持中英文混合
    turnFeatures := make([][]string, len(turns))
    for i, turn := range turns {
        turnFeatures[i] = extractKeywords(turn.Text())
    }
    
    // 步骤 3: 计算相邻轮次的相似度
    boundaries := []int{0}
    for i := 1; i < len(turnFeatures); i++ {
        similarity := cosineSimilarity(turnFeatures[i-1], turnFeatures[i])
        if similarity < d.CosineThreshold {
            lastBoundary := boundaries[len(boundaries)-1]
            if i - lastBoundary >= d.MinSegmentSize {
                boundaries = append(boundaries, i)
            }
        }
    }
    boundaries = append(boundaries, len(turns))
    
    // 步骤 4: 构建话题片段
    var segments []TopicSegment
    for i := 0; i < len(boundaries)-1; i++ {
        seg := TopicSegment{
            ID:       fmt.Sprintf("topic_%d", i),
            StartIdx: turns[boundaries[i]].StartMsgIdx,
            EndIdx:   turns[boundaries[i+1]-1].EndMsgIdx,
            Keywords: mergeKeywords(turnFeatures[boundaries[i]:boundaries[i+1]]),
            IsCurrent: i == len(boundaries)-2,
        }
        seg.MessageCount = seg.EndIdx - seg.StartIdx + 1
        segments = append(segments, seg)
    }
    
    return segments
}

// extractKeywords 从文本中提取关键词（规则方法，无需 LLM）
// 支持中英文混合：英文用空格/正则分词，CJK 字符按 bigram 拆分
func extractKeywords(text string) []string {
    keywords := make(map[string]bool)
    
    // 1. 提取文件路径模式
    for _, fp := range filepathPattern.FindAllString(text, -1) {
        keywords[strings.ToLower(fp)] = true
    }
    
    // 2. 提取代码标识符（驼峰/下划线命名）
    for _, id := range identifierPattern.FindAllString(text, -1) {
        keywords[strings.ToLower(id)] = true
    }
    
    // 3. 提取英文单词（去除常见停用词）
    words := tokenizeEnglish(text)
    for _, w := range removeStopWords(words) {
        keywords[strings.ToLower(w)] = true
    }
    
    // 4. 提取 CJK 字符序列（中文/日文/韩文）
    // 策略：使用 bigram（相邻两个字符为一组），而非依赖外部分词库
    // 原因：避免引入 jieba 等重量级依赖，bigram 对话题切换检测足够
    // 示例："上下文管理" → ["上下", "下文", "文管", "管理"]
    cjkChars := extractCJKChars(text) // 提取连续 CJK 字符序列
    for _, segment := range cjkChars {
        runes := []rune(segment)
        for j := 0; j < len(runes)-1; j++ {
            keywords[string(runes[j:j+2])] = true // bigram
        }
    }
    
    // 5. 转换为列表
    result := make([]string, 0, len(keywords))
    for k := range keywords {
        result = append(result, k)
    }
    return result
}

// extractCJKChars 从文本中提取连续的 CJK 字符序列
// 使用 Unicode 范围：\p{Han}（中文）、\p{Hiragana}+\p{Katakana}（日文）、\p{Hangul}（韩文）
var cjkPattern = regexp.MustCompile(`[\p{Han}\p{Hiragana}\p{Katakana}\p{Hangul}]+`)

func extractCJKChars(text string) []string {
    return cjkPattern.FindAllString(text, -1)
}

// tokenizeEnglish 提取英文单词
var englishWordPattern = regexp.MustCompile(`[a-zA-Z][a-zA-Z0-9_]*`)

func tokenizeEnglish(text string) []string {
    return englishWordPattern.FindAllString(text, -1)
}

// SelectiveCompressor 选择性压缩器
type SelectiveCompressor struct {
    detector *TopicDetector
}

// Compress 选择性压缩：保留当前话题完整，压缩历史话题
func (sc *SelectiveCompressor) Compress(
    ctx context.Context,
    messages []llm.ChatMessage,
    client llm.LLM,
    model string,
) (*CompressResult, error) {
    
    // 1. 检测话题分区
    segments := sc.detector.Detect(messages)
    
    if len(segments) <= 1 {
        // 只有一个话题，走标准压缩（Phase 1 逻辑）
        return standardCompress(ctx, messages, client, model)
    }
    
    // 2. 分离当前话题和历史话题
    var currentMsgs, historyMsgs []llm.ChatMessage
    for _, seg := range segments {
        if seg.IsCurrent {
            currentMsgs = messages[seg.StartIdx : seg.EndIdx+1]
        } else {
            historyMsgs = append(historyMsgs, messages[seg.StartIdx:seg.EndIdx+1]...)
        }
    }
    
    // 3. 压缩历史话题（可按话题分别压缩，保留话题标记）
    compressedHistory := sc.compressHistoryByTopic(ctx, historyMsgs, segments, client, model)
    
    // 4. 构建双视图
    historySummary := buildTopicAnnotatedSummary(compressedHistory)
    summaryMsg := llm.NewUserMessage("[Previous conversation context]\n\n" + historySummary)
    
    // LLM View: 保留当前话题的 tool 消息（API 兼容）
    llmView := []llm.ChatMessage{summaryMsg}
    llmView = append(llmView, currentMsgs...)
    
    // Session View: 当前话题提取对话视图
    currentSessionView := extractDialogueFromTail(currentMsgs)
    sessionView := []llm.ChatMessage{summaryMsg}
    sessionView = append(sessionView, currentSessionView...)
    
    return &CompressResult{
        LLMView:     llmView,
        SessionView: sessionView,
    }, nil
}

// 在 processMessage 中集成话题切换检测
func (a *Agent) processMessage(ctx context.Context, msg bus.InboundMessage) (*bus.OutboundMessage, error) {
    // ... 现有逻辑 ...
    
    tenantSession, err := a.multiSession.GetOrCreateSession(msg.Channel, msg.ChatID)
    
    // === Phase 2 新增：话题切换检测（同步压缩） ===
    if a.topicDetector != nil && a.enableAutoCompress && a.enableTopicIsolation {
        history, _ := tenantSession.GetMessages()
        if len(history) > 10 { // 至少 10 条消息才检测（避免误判）
            segments := a.topicDetector.Detect(history)
            
            if len(segments) > 1 {
                latestSeg := segments[len(segments)-1]
                // 最新话题只有 1-2 条消息（刚切换）
                if latestSeg.MessageCount <= 2 {
                    log.Ctx(ctx).WithFields(log.Fields{
                        "old_topic": segments[len(segments)-2].Keywords,
                        "new_topic": latestSeg.Keywords,
                    }).Info("Topic switch detected, triggering synchronous selective compression")
                    
                    // ⚠️ 同步压缩（不能 go 异步，避免并发写入 session）
                    // 压缩耗时（LLM 调用）约 1-3 秒，在用户消息处理前期可接受
                    result, err := a.selectiveCompressor.Compress(ctx, history, a.client, a.cfg.Model)
                    if err == nil {
                        // 压缩成功，替换 session 消息
                        tenantSession.Clear()
                        for _, m := range result.SessionView {
                            tenantSession.AddMessage(m)
                        }
                    } else {
                        log.Ctx(ctx).WithError(err).Warn("Selective compression failed, continuing with full history")
                    }
                }
            }
        }
    }
    
    // ... 后续逻辑不变 ...
}

// KeyInfoFingerprint 关键信息指纹
type KeyInfoFingerprint struct {
    // 文件路径（压缩后应保留所有被引用的文件路径）
    FilePaths []string `json:"file_paths"`
    
    // 函数/类型/变量名（压缩后应保留关键标识符）
    Identifiers []string `json:"identifiers"`
    
    // 错误信息（压缩后必须保留所有遇到的错误）
    Errors []string `json:"errors"`
    
    // 决策记录（压缩后应保留关键决策）
    Decisions []string `json:"decisions"`
    
    // 待办/未完成任务
    PendingTasks []string `json:"pending_tasks"`
}

// ExtractFingerprint 从消息列表中提取关键信息指纹
// 子函数实现说明：
// - extractPathsFromJSON: 从 JSON 字符串中提取 "path"/"file" 字段值
// - extractFilePaths: 从文本中用正则提取 ./xxx、/xxx、xxx.go 等路径模式
// - extractCodeIdentifiers: 提取驼峰/下划线命名的代码标识符
// - isErrorContext: 检测文本是否包含错误上下文（error, panic, failed, 40x, 50x）
// - extractErrorMessages: 从错误上下文中提取具体错误描述（error行/JSON错误消息）
// - extractDecisions: 提取决策标记（"决定"、"decided"、"choose" 等模式后的内容）
func ExtractFingerprint(messages []llm.ChatMessage) KeyInfoFingerprint {
    fp := KeyInfoFingerprint{}
    seen := make(map[string]bool)
    
    addUnique := func(items []string, target *[]string) {
        for _, item := range items {
            if !seen[item] {
                seen[item] = true
                *target = append(*target, item)
            }
        }
    }
    
    for _, msg := range messages {
        text := msg.Content
        if msg.Role == "tool" {
            // 从工具参数中提取文件路径
            if paths := extractPathsFromJSON(msg.ToolArguments); len(paths) > 0 {
                addUnique(paths, &fp.FilePaths)
            }
        }
        
        addUnique(extractFilePaths(text), &fp.FilePaths)
        addUnique(extractCodeIdentifiers(text), &fp.Identifiers)
        
        if isErrorContext(text) {
            addUnique(extractErrorMessages(text), &fp.Errors)
        }
        
        addUnique(extractDecisions(text), &fp.Decisions)
    }
    
    return fp
}

// ValidateCompression 校验压缩质量
// 返回保留率 (0.0-1.0) 和丢失的关键信息列表
func ValidateCompression(original, compressed string, fp KeyInfoFingerprint) (float64, []string) {
    total := len(fp.FilePaths) + len(fp.Errors) + len(fp.Decisions)
    if total == 0 {
        return 1.0, nil // 无关键信息需保留
    }
    
    retained := 0
    var lost []string
    
    for _, path := range fp.FilePaths {
        if strings.Contains(compressed, path) {
            retained++
        } else {
            lost = append(lost, "文件路径: "+path)
        }
    }
    
    for _, err := range fp.Errors {
        if strings.Contains(compressed, err) || containsSemanticMatch(compressed, err) {
            retained++
        } else {
            lost = append(lost, "错误信息: "+err)
        }
    }
    
    for _, d := range fp.Decisions {
        if strings.Contains(compressed, d) || containsSemanticMatch(compressed, d) {
            retained++
        } else {
            lost = append(lost, "决策: "+d)
        }
    }
    
    return float64(retained) / float64(total), lost
}

// containsSemanticMatch 语义模糊匹配
// 用于检测压缩摘要中是否"语义上"保留了某条信息（即使措辞不同）
// 实现策略（轻量级，无 LLM 依赖）：
//   1. 精确子串匹配（已在外层做）
//   2. 归一化后子串匹配：统一大小写、去除标点、去除空格
//   3. 关键词重叠度：将原始文本拆分为关键词（空格/标点分割），
//      检查压缩文本中包含的关键词比例是否 >= 0.6
//   4. 编辑距离（可选）：对于短文本（<50字符），检查编辑距离/长度比 < 0.3
func containsSemanticMatch(compressed, target string) bool {
    // 策略 1: 归一化后子串匹配
    normalized := strings.ToLower(strings.ReplaceAll(strings.ReplaceAll(compressed, " ", ""), ".", ""))
    normalizedTarget := strings.ToLower(strings.ReplaceAll(strings.ReplaceAll(target, " ", ""), ".", ""))
    if strings.Contains(normalized, normalizedTarget) {
        return true
    }
    
    // 策略 2: 关键词重叠度
    targetWords := splitToWords(target)
    if len(targetWords) == 0 {
        return false
    }
    matched := 0
    for _, w := range targetWords {
        if strings.Contains(normalized, strings.ToLower(w)) {
            matched++
        }
    }
    overlapRatio := float64(matched) / float64(len(targetWords))
    if overlapRatio >= 0.6 {
        return true
    }
    
    // 策略 3: 短文本编辑距离
    if len([]rune(target)) < 50 {
        // 简化版 Levenshtein 距离检查（仅比较归一化后的前缀/后缀）
        // 完整 Levenshtein 对长文本太慢，此处用启发式
        if strings.HasPrefix(normalized, normalizedTarget[:len(normalizedTarget)/2]) {
            return true
        }
    }
    
    return false
}

// splitToWords 将文本拆分为关键词（去除常见停用词和短词）
func splitToWords(text string) []string {
    // 按空格和标点分割
    parts := regexp.MustCompile(`[\s,.\-:;!?/\\|(){}[\]<>]+`).Split(text, -1)
    stopWords := map[string]bool{"the": true, "a": true, "an": true, "is": true, "are": true,
        "was": true, "were": true, "in": true, "on": true, "at": true, "to": true, "for": true,
        "of": true, "and": true, "or": true, "的": true, "了": true, "是": true, "在": true}
    var result []string
    for _, p := range parts {
        p = strings.ToLower(strings.TrimSpace(p))
        if len(p) > 1 && !stopWords[p] {
            result = append(result, p)
        }
    }
    return result
}