xbot 上下文管理改进：设计文档

// 当前注释（有问题）：
// 核心原则：
// 1. 保留所有 tool 消息（tool_calls 和 tool result 必须配对，否则 API 报错）  ← 仅为 API 兼容
// 2. 把压缩后的摘要作为 user prompt 直接调用 LLM
// 3. 保留 system 消息和最近的对话轮次

// 持久化压缩结果到 session
if cfg.Session != nil {
    cfg.Session.Clear()
    for _, msg := range compressed {  // ← compressed 含 tool 消息
        if msg.Role == "system" { continue }
        cfg.Session.AddMessage(msg)  // ← tool 消息写入 session ❌
    }
}

// CompressResult 压缩结果，区分 LLM 视图和 Session 视图
type CompressResult struct {
    // LLMView 用于继续当前 Run() 循环的 LLM 调用
    // 可能包含 tool 消息（API 兼容性需要）
    LLMView []llm.ChatMessage
    
    // SessionView 用于持久化到 session
    // 只包含 user + assistant（无 tool）消息
    // tool 执行的关键信息已融入压缩摘要
    SessionView []llm.ChatMessage
}

func (a *Agent) compressContext(ctx context.Context, messages []llm.ChatMessage, 
    client llm.LLM, model string) (*CompressResult, error) {
    
    // 第一步：找到尾部安全切割点（不变）
    tailStart := findSafeTailStart(messages)
    
    // 第二步：分离 thinnedTail（用于 LLM View）
    thinnedTail := thinTail(messages[tailStart:], 3)
    
    // 第三步：从 thinnedTail 提取对话摘要（用于 Session View）
    tailSummary := extractDialogueFromTail(thinnedTail)
    
    // 第四步：压缩旧历史（不变）
    compressed := compressOldHistory(messages[:tailStart], client, model)
    
    // 构建两个视图
    llmView := []llm.ChatMessage{systemMsg}
    llmView = append(llmView, userSummaryMsg(compressed))
    llmView = append(llmView, thinnedTail...)  // 含 tool 消息
    
    sessionView := []llm.ChatMessage{}
    sessionView = append(sessionView, userSummaryMsg(compressed))  // 压缩摘要
    sessionView = append(sessionView, tailSummary...)  // 尾部对话摘要
    
    return &CompressResult{
        LLMView:    llmView,
        SessionView: sessionView,
    }, nil
}

// extractDialogueFromTail 从含 tool 消息的尾部提取 user/assistant 对话
// 每个 tool group 的效果被摘要为 assistant 消息的一部分
func extractDialogueFromTail(tail []llm.ChatMessage) []llm.ChatMessage {
    var result []llm.ChatMessage
    var pendingToolSummary strings.Builder  // 累积当前轮的 tool 执行摘要
    
    for _, msg := range tail {
        switch {
        case msg.Role == "user":
            flushPending(&result, &pendingToolSummary)
            result = append(result, llm.NewUserMessage(msg.Content))
            
        case msg.Role == "assistant" && len(msg.ToolCalls) > 0:
            // assistant 发起了 tool call，记录工具名称
            flushPending(&result, &pendingToolSummary)
            if msg.Content != "" {
                // assistant 有文本内容，先记录
                pendingToolSummary.WriteString(msg.Content + "\n")
            }
            for _, tc := range msg.ToolCalls {
                pendingToolSummary.WriteString(fmt.Sprintf("🔧 %s(%s)\n", tc.Name, truncateArgs(tc.Arguments, 100)))
            }
            
        case msg.Role == "assistant":
            flushPending(&result, &pendingToolSummary)
            result = append(result, llm.NewAssistantMessage(msg.Content))
            
        case msg.Role == "tool":
            // tool result，累积摘要（截断长内容）
            toolContent := truncateRunes(msg.Content, 200)
            pendingToolSummary.WriteString(fmt.Sprintf("  → %s\n", toolContent))
        }
    }
    flushPending(&result, &pendingToolSummary)
    return result
}

// flushPending 将累积的 tool 执行摘要作为 assistant 消息添加到结果
func flushPending(result *[]llm.ChatMessage, builder *strings.Builder) {
    if builder.Len() == 0 {
        return
    }
    *result = append(*result, llm.NewAssistantMessage(builder.String()))
    builder.Reset()
}

maybeCompress := func() {
    // ... 触发判断逻辑不变 ...
    
    result, compressErr := cc.CompressFunc(ctx, messages, cfg.LLMClient, cfg.Model)
    // ...
    
    // LLM View：继续当前 Run
    messages = result.LLMView
    
    // Session View：持久化到 session（不含 tool 消息）
    if cfg.Session != nil {
        cfg.Session.Clear()
        for _, msg := range result.SessionView {
            cfg.Session.AddMessage(msg)  // 纯 user/assistant
        }
    }
}

// 当前
CompressionThreshold: 0.8  // 80% 触发

// 建议（参考 Claude Code 64-75% 策略）
CompressionThreshold: 0.7  // 70% 触发，留 30% completion buffer

compressionPrompt := `You are a context compression expert. ...

## Compression Rules
1. Retain ALL key facts, decisions, and important details
2. Keep track of what the user has asked for and what has been done
3. Preserve any file paths, code snippets, or technical details
4. Maintain the logical flow and context of the conversation
5. Note any errors or issues that were encountered
6. **For tool execution sequences**: summarize what was done and the result,
   but don't include raw tool call/request format
7. Preserve any open questions or unfinished tasks
8. Include the current working directory and any important state
`

// 当前
thinTail(tail, 3)  // 保留最近 3 组 tool group

// 建议不变，但增加日志
// 最近 3 组 tool call 对应的对话轮次，确保当前任务有足够上下文继续

// cleanupToolMessages 清理 session 中的 tool 消息
func cleanupToolMessages(tenantSession *session.TenantSession) error {
    messages, err := tenantSession.GetAllMessages()
    if err != nil {
        return err
    }
    
    var clean []llm.ChatMessage
    for _, msg := range messages {
        // 跳过 tool 消息和含 tool_calls 的 assistant 消息
        if msg.Role == "tool" {
            continue
        }
        if msg.Role == "assistant" && len(msg.ToolCalls) > 0 {
            // 如果 assistant 消息只有 tool_calls 无 content，跳过
            if strings.TrimSpace(msg.Content) == "" {
                continue
            }
            // 如果有 content，保留但移除 ToolCalls
            msg.ToolCalls = nil
        }
        clean = append(clean, msg)
    }
    
    tenantSession.Clear()
    for _, msg := range clean {
        tenantSession.AddMessage(msg)
    }
    return nil
}