Phase 1.5 上下文压缩重构方案

// ActiveFile 最近 N 轮活跃文件记录
type ActiveFile struct {
    Path         string   // 文件路径
    LastSeenIter int      // 最后出现的轮次
    Functions    []string // 涉及的函数签名（从 tool result 中提取）
}

// ExtractActiveFiles 从最近 N 轮 tool call 中提取活跃文件。
// 扫描 messages 尾部的 tool call，提取 Read/Edit/Shell 等涉及的文件路径。
func ExtractActiveFiles(messages []llm.ChatMessage, lastN int) []ActiveFile

type KeyInfoFingerprint struct {
    FilePaths    []string      // 原有
    Identifiers  []string      // 原有
    Errors       []string      // 原有
    Decisions    []string      // 原有
    ActiveFiles  []ActiveFile  // 新增：最近 N 轮的活跃文件
}

func ExtractFingerprint(messages []llm.ChatMessage) KeyInfoFingerprint {
    // ... 原有逻辑 ...
    
    // 新增：提取活跃文件
    fp.ActiveFiles = ExtractActiveFiles(messages, 3)
    return fp
}

const taskStatePrompt = `You are a task state extraction expert. Extract the current task state from the conversation into a structured document.

## Goal
Transform verbose conversation history into a concise, structured task state document.
Focus on WHAT has been done, WHAT is in progress, and WHAT remains.

## Output Format
Use these structured sections and markers:

### 📋 Task Summary
Brief overview of what the user asked for and current progress.

### 📁 Active Files
@file:{path} — Files currently being worked on (MUST include ALL active file references)
@func:{signature} — Key function signatures from active files

### ✅ Completed Steps
- What has been done so far (with file paths and specific details)

### 🔄 Current Step
What is being worked on right now. Include:
- Current file being edited/read
- Pending modifications
- Context needed to continue

### ❌ Errors (MUST preserve ALL)
@error:{description} — Every error encountered (essential for debugging)

### 📌 Decisions
@decision:{description} — All decisions made during this session

### 📝 Pending Tasks
@todo:{description} — Tasks not yet started

## Compression Rules
1. PRESERVE ALL file paths that appear in active file operations
2. PRESERVE ALL error messages verbatim
3. PRESERVE all function signatures from active files
4. Include specific details (variable names, line numbers, code snippets)
5. If 📂 [offload:...] markers exist, preserve them verbatim
6. Prioritize RECENT information over old history
7. This is NOT a summary — it's a task state document for continuing work`

if len(fp.ActiveFiles) > 0 {
    fpSection.WriteString("\n## ACTIVE FILES (must be fully preserved in output):\n")
    for _, af := range fp.ActiveFiles {
        fmt.Fprintf(&fpSection, "  @file:%s\n", af.Path)
        for _, fn := range af.Functions {
            fmt.Fprintf(&fpSection, "  @func:%s\n", fn)
        }
    }
}

// thinTail 精简尾部旧工具组，保留最近 keepGroups 组完整内容。
// activeFiles: 活跃文件集合，涉及这些文件的 tool 组不会被截断。
func thinTail(tail []llm.ChatMessage, keepGroups int, activeFiles []ActiveFile) []llm.ChatMessage

// 第二步：精简尾部旧工具组
activeFiles := ExtractActiveFiles(messages, 3)
var thinnedTail []llm.ChatMessage
if tailStart < len(messages) {
    thinnedTail = thinTail(messages[tailStart:], 1, activeFiles)
}

// 旧（第216-217行）：
// Phase 2: 三层渐进压缩（Offload → Evict → Compact）
log.WithField("mode", mode).Info("Using Phase 2 smart compression (Offload → Evict → Compact)")
// 新：
// Phase 2: 智能压缩（Offload → Compact，无 Evict 层）
log.WithField("mode", mode).Info("Using Phase 1.5 smart compression (Offload → Compact)")

// 旧：
// ContextModePhase2 Phase 2 三层渐进压缩
// 新：
// ContextModePhase2 Phase 2 智能压缩（Offload → Compact，含 fingerprint 引导与活跃文件保护）

func (m *phase2Manager) Compress(ctx context.Context, messages []llm.ChatMessage, client llm.LLM, model string) (*CompressResult, error) {
    originalTokens, _ := llm.CountMessagesTokens(messages, model)

    log.Ctx(ctx).WithFields(map[string]interface{}{
        "original_tokens": originalTokens,
        "max_tokens":      m.config.MaxContextTokens,
    }).Info("Phase 1.5 compress: starting")

    // 步骤1：提取指纹（含活跃文件）
    fp := ExtractFingerprint(messages)

    // 步骤2：带 fingerprint 引导的 LLM 压缩
    result, err := compressMessagesWithFingerprint(ctx, messages, fp, client, model)
    if err != nil {
        return nil, err
    }

    // 步骤3：质量校验
    compressedText := joinMessages(result.SessionView)
    compressedTokens, _ := llm.CountMessagesTokens(result.LLMView, model)
    quality := EvaluateQuality(originalTokens, compressedTokens, fp, compressedText)

    _, lostItems := ValidateCompression(messages, result.SessionView, fp)
    retentionRate := 1.0
    if totalItems := len(fp.FilePaths) + len(fp.Identifiers) + len(fp.Errors) + len(fp.Decisions); totalItems > 0 {
        retentionRate = float64(totalItems-len(lostItems)) / float64(totalItems)
    }

    // 步骤4：低质量重试
    if quality < 0.6 && retentionRate < 0.8 && client != nil && len(lostItems) > 0 {
        retryResult, retryErr := compressMessagesWithFingerprintAndLostItems(ctx, messages, fp, lostItems, client, model)
        if retryErr == nil {
            retryText := joinMessages(retryResult.SessionView)
            retryTokens, _ := llm.CountMessagesTokens(retryResult.LLMView, model)
            retryQuality := EvaluateQuality(originalTokens, retryTokens, fp, retryText)
            if retryQuality > quality {
                quality = retryQuality
                result = retryResult
            }
        }
    }

    // 步骤5：标记完整性检测
    missingMarkers := ValidateMarkers(compressedText, fp)
    if len(missingMarkers) > 0 {
        log.Ctx(ctx).WithFields(map[string]interface{}{
            "missing_markers": len(missingMarkers),
            "quality_score":   quality,
        }).Warn("Phase 1.5 compress missing structured markers")
    }

    log.Ctx(ctx).WithFields(map[string]interface{}{
        "quality_score":  quality,
        "retention_rate": retentionRate,
        "markers":        countStructuredMarkers(compressedText),
        "new_tokens":     compressedTokens,
    }).Info("Phase 1.5 compress quality report")

    return result, nil
}

func (m *phase2Manager) ManualCompress(ctx context.Context, messages []llm.ChatMessage, client llm.LLM, model string) (*CompressResult, error) {
    fp := ExtractFingerprint(messages)
    result, err := compressMessagesWithFingerprint(ctx, messages, fp, client, model)
    if err != nil {
        // 降级到不带指纹的压缩
        return compressMessages(ctx, messages, client, model)
    }
    return result, nil
}