Phase 2 上下文管理实施计划

type TriggerInfo struct {
    MaxTokens       int       // 最大上下文 token 数
    CurrentTokens   int       // 当前消息 token 数
    IterationCount  int       // 当前 Run() 迭代次数
    ToolCallCount   int       // 本次 Run() 的工具调用总次数
    TokenHistory    []int     // 最近 N 次迭代的 token 快照（滑窗）
    GrowthRate      float64   // 近期 token 增长速率
    RecentTools     []string  // 最近 5 次工具调用名称
    ToolPattern     ToolCallPattern
}

type ToolCallPattern int
const (
    PatternConversation ToolCallPattern = iota
    PatternReadHeavy
    PatternWriteHeavy
    PatternMixed
    PatternSubAgent
)

type TokenGrowthTracker struct {
    window  []tokenSnapshot  // 滑动窗口（默认 10）
    maxSize int
}

type CompressCooldown struct {
    lastCompressIteration int
    cooldownIterations    int  // 默认 3
}

ShouldCompress(messages []llm.ChatMessage, model string, toolTokens int) bool

// SmartCompressor 智能压缩接口（Phase 2 扩展）
type SmartCompressor interface {
    // ShouldCompressDynamic 使用完整触发信息判断是否需要压缩
    ShouldCompressDynamic(info TriggerInfo) bool
    // Provider 返回触发信息提供者（用于 engine.go 填充 GrowthTracker 和 Cooldown）
    Provider() *TriggerInfoProvider
}

// TriggerInfoProvider 提供压缩触发信息
type TriggerInfoProvider struct {
    GrowthTracker *TokenGrowthTracker
    Cooldown      *CompressCooldown
}

func NewTriggerInfoProvider() *TriggerInfoProvider {
    return &TriggerInfoProvider{
        GrowthTracker: &TokenGrowthTracker{maxSize: 10},
        Cooldown:      &CompressCooldown{cooldownIterations: 3},
    }
}

// Reset 重置所有状态（用于 /new 命令）
func (p *TriggerInfoProvider) Reset() {
    p.GrowthTracker.Reset()
    p.Cooldown.Reset()
}

if smart, ok := cm.(SmartCompressor); ok {
    // 每次 Run() 开始时获取 Provider，确保引用最新
    provider := smart.Provider()
    triggerInfo := BuildTriggerInfo(i, messages, toolsUsed, provider, cfg)
    shouldCompress = smart.ShouldCompressDynamic(triggerInfo)
    // 无论是否压缩，都记录 token 快照
    provider.GrowthTracker.Record(i, msgTokens)
} else {
    shouldCompress = cm.ShouldCompress(messages, cfg.Model, toolTokens)
}

type Agent struct {
    // ... 现有字段 ...

    // Phase 2: 智能触发状态（按 sessionKey 索引）
    triggerProviders sync.Map // map[string]*TriggerInfoProvider，key = sessionKey
}

// getTriggerProvider 获取或创建指定 session 的 TriggerInfoProvider
func (a *Agent) getTriggerProvider(sessionKey string) *TriggerInfoProvider {
    if v, ok := a.triggerProviders.Load(sessionKey); ok {
        return v.(*TriggerInfoProvider)
    }
    provider := NewTriggerInfoProvider()
    actual, _ := a.triggerProviders.LoadOrStore(sessionKey, provider)
    return actual.(*TriggerInfoProvider)
}

a.triggerProviders.Delete(sessionKey)

type KeyInfoFingerprint struct {
    FilePaths    []string `json:"file_paths"`
    Identifiers  []string `json:"identifiers"`
    Errors       []string `json:"errors"`
    Decisions    []string `json:"decisions"`
}

const structuredCompressionPrompt = `You are a context compression expert...

## OUTPUT FORMAT
Use these markers:
@file:{path} — File references
@func:{name} — Function signatures
@type:{name} — Type definitions
@error:{description} — Errors encountered
@decision:{description} — Decisions made
@todo:{description} — Pending tasks
@config:{key=value} — Config changes
...`

case msg.Role == "tool":
    if strings.HasPrefix(msg.Content, "📂 [offload:") {
        // 保留 offload 摘要完整，不截断
        pendingToolSummary.WriteString(msg.Content + "\n")
    } else {
        toolContent := truncateRunes(msg.Content, 200)
        ...
    }

type OffloadConfig struct {
    MaxResultTokens int    // 默认 2000
    MaxResultBytes  int    // 默认 10240
    StoreDir        string // 默认 {DataDir}/offload_store/
    CleanupAgeDays  int    // 默认 7（启动时清理 N 天前的残留数据）
}

type OffloadedResult struct {
    ID        string
    ToolName  string
    Args      string
    FilePath  string
    TokenSize int
    Timestamp time.Time
    Summary   string
}

type OffloadStore struct {
    config    OffloadConfig
    sessionMu sync.Map // map[sessionKey]*sessionIndex
}

type offloadIndex struct {
    mu      sync.RWMutex
    entries []OffloadedResult
}

func generateRuleSummary(toolName, args, content string) string {
    switch {
    case toolName == "Read":
        return summarizeFileRead(args, content)    // 文件名+行数+首尾+关键函数
    case toolName == "Grep":
        return summarizeGrepResult(content)         // 匹配数+前3条
    case toolName == "Shell":
        return summarizeShellOutput(content)         // 退出码+最后5行
    default:
        return summarizeGeneric(content)             // 前300字符+N tokens已offload
    }
}

// CleanStale 在 Agent 启动时调用，清理超过 CleanupAgeDays 天的 offload 数据
func (s *OffloadStore) CleanStale() {
    cutoff := time.Now().AddDate(0, 0, -s.config.CleanupAgeDays)
    // 遍历 StoreDir，删除 mtime < cutoff 的 session 目录
    // 记录清理日志
}

type OffloadRecallTool struct {
    store *agent.OffloadStore // 依赖注入
}

func (t *OffloadRecallTool) Name() string { return "offload_recall" }
func (t *OffloadRecallTool) Description() string { return "召回已 offload 的工具结果完整内容" }
func (t *OffloadRecallTool) Parameters() []llm.ToolParam {
    return []llm.ToolParam{
        {Name: "id", Type: "string", Description: "offload ID（从工具结果中的 📂 标记获取）", Required: true},
    }
}

func (t *OffloadRecallTool) Execute(ctx *tools.ToolContext, args string) (*tools.ToolResult, error) {
    // 1. 解析 args 获取 ID
    var params struct{ ID string `json:"id"` }
    if err := json.Unmarshal([]byte(args), &params); err != nil {
        return nil, fmt.Errorf("invalid args: %w", err)
    }

    // 2. 从 ToolContext 获取 sessionKey
    //    ToolContext 包含 session 信息，通过 ctx.SessionID() 或类似方法获取
    sessionKey := ctx.SessionID()
    if sessionKey == "" {
        return nil, fmt.Errorf("offload_recall requires a session context")
    }

    // 3. 调用 store.Recall(sessionKey, id)
    content, err := t.store.Recall(sessionKey, params.ID)
    if err != nil {
        return nil, fmt.Errorf("offload recall failed: %w", err)
    }

    // 4. 返回完整内容（如果超过 8000 字符则截断并提示）
    if len([]rune(content)) > 8000 {
        content = content[:8000] + "\n\n[内容过长，已截断。如需更多请指定范围。]"
    }

    return &tools.ToolResult{LLMContent: content}, nil
}

// Phase 2: offload_recall 工具（仅主 Agent 使用）
if a.offloadStore != nil {
    recallTool := &tools.OffloadRecallTool{Store: a.offloadStore}
    a.toolsRegistry.Register(recallTool)
}

// 工具执行结果处理循环中
for idx, tc := range response.ToolCalls {
    r := execResults[idx]
    content := r.llmContent

    // === Phase 2: Layer 1 Offload ===
    if offloadStore != nil && !r.err {
        offloaded, wasOffloaded := offloadStore.MaybeOffload(sessionKey, tc.Name, tc.Arguments, content)
        if wasOffloaded {
            content = offloaded.Summary
            log.Ctx(ctx).WithFields(log.Fields{
                "tool":         tc.Name,
                "offload_id":   offloaded.ID,
                "tokens_saved": offloaded.TokenSize,
            }).Info("Tool result offloaded")
        }
    }

    toolMsg := llm.NewToolMessage(tc.Name, tc.ID, tc.Arguments, content)
    ...
}

a.offloadStore = agent.NewOffloadStore(agent.OffloadConfig{
    StoreDir:       filepath.Join(a.dataDir, "offload_store"),
    CleanupAgeDays: 7,
})
a.offloadStore.CleanStale() // 启动时清理残留

type RunConfig struct {
    // ... 现有字段 ...
    OffloadStore *agent.OffloadStore // Phase 2: offload store（nil = 不启用）
}

if a.offloadStore != nil {
    a.offloadStore.CleanSession(sessionKey)
}

// DensityScore 信息密度评分
type DensityScore struct {
    Score float64
    Index int
}

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

    // Offload 标记消息：已是摘要，不再驱逐（保留引用标记供 offload_recall 使用）
    if strings.HasPrefix(content, "📂 [offload:") {
        return 1.0 // 中性分数，不会被优先驱逐
    }

    // 高密度信号
    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 }
    if msg.Role == "tool" && len([]rune(content)) > 3000 { score -= 2.0 }

    return score
}

// evictByDensity 按信息密度驱逐旧 tool result
func evictByDensity(messages []llm.ChatMessage, keepGroups int, targetTokens int, model string) []llm.ChatMessage {
    // 1. 识别工具组（复用 thinTail 的组识别逻辑）
    // 2. 保留尾部 keepGroups 组完整
    // 3. 对剩余 tool 消息按密度评分排序
    // 4. 从低密度开始驱逐：替换 tool result 为 "[evicted] 工具摘要（N tokens 已驱逐）"
    // 5. 跳过含有 📂 [offload:...] 标记的消息（已是摘要，驱逐无意义）
    // 6. 驱逐直到 targetTokens 以下
}

func (m *phase2Manager) Compress(ctx context.Context, messages []llm.ChatMessage, client llm.LLM, model string) (*CompressResult, error) {
    // Phase 1: Evict（信息密度驱逐）
    targetTokens := int(float64(m.config.MaxContextTokens) * 0.7)
    evicted := evictByDensity(messages, 3, targetTokens, model)
    evictTokens, _ := llm.CountMessagesTokens(evicted, model)

    // Phase 2: Compact（如果 Evict 后仍超阈值）
    if evictTokens >= int(float64(m.config.MaxContextTokens)*m.config.CompressionThreshold) {
        return compressMessages(ctx, evicted, client, model)
    }

    // Evict 后已足够，构建双视图
    return buildCompressResultFromEvicted(evicted), nil
}

// ValidateMarkers 检查压缩输出是否包含必要的结构化标记
func ValidateMarkers(compressed string, fp KeyInfoFingerprint) []string {
    var missing []string
    for _, path := range fp.FilePaths {
        if !strings.Contains(compressed, "@file:"+path) && !strings.Contains(compressed, path) {
            missing = append(missing, "文件: "+path)
        }
    }
    for _, err := range fp.Errors {
        if !strings.Contains(compressed, "@error:") && !containsSemanticMatch(compressed, err) {
            missing = append(missing, "错误: "+err)
        }
    }
    return missing
}

type TopicDetector struct {
    CosineThreshold float64  // 默认 0.3
    MinSegmentSize  int      // 默认 3
}

type TopicSegment struct {
    ID           string
    StartIdx     int
    EndIdx       int
    MessageCount int
    Keywords     []string
    Summary      string
    IsCurrent    bool
}

type SelectiveCompressor struct {
    detector *TopicDetector
}

func (sc *SelectiveCompressor) Compress(ctx, messages, client, model) (*CompressResult, error)

// Phase 2: 话题切换检测（同步压缩）
if a.topicDetector != nil && a.enableTopicIsolation {
    history, _ := tenantSession.GetMessages()
    if len(history) > 10 {
        segments := a.topicDetector.Detect(history)
        if len(segments) > 1 && segments[len(segments)-1].MessageCount <= 2 {
            // 同步压缩（不能异步，session 非线程安全）
            result, err := a.selectiveCompressor.Compress(ctx, history, client, model)
            if err == nil {
                tenantSession.Clear()
                for _, msg := range result.SessionView {
                    tenantSession.AddMessage(msg)
                }
            }
        }
    }
}

type Agent struct {
    // ... 现有字段 ...
    topicDetector        *TopicDetector
    selectiveCompressor  *SelectiveCompressor
    enableTopicIsolation bool
}

EnableTopicIsolation        bool    `json:"enable_topic_isolation"`     // 默认 false（实验性）
TopicMinSegmentSize         int     `json:"topic_min_segment_size"`     // 默认 3
TopicSimilarityThreshold    float64 `json:"topic_similarity_threshold"` // 默认 0.3