┌─────────────────────────────────────────────────────────────────┐
│                     Aster Agent SDK                             │
├─────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │                  Memory System                           │   │
│  ├─────────────────────────────────────────────────────────┤   │
│  │  Text Memory  │ Working Memory │ Semantic Memory │ NEW  │   │
│  │  (agent.md)   │ (临时状态)      │ (向量检索)      │ Logic│   │
│  │               │                 │                 │Memory│   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │              Logic Memory Framework                      │   │
│  ├─────────────────────────────────────────────────────────┤   │
│  │                                                           │   │
│  │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐  │   │
│  │  │  Capture     │  │   Storage    │  │  Retrieval   │  │   │
│  │  │  捕获层      │  │   存储层     │  │  检索层      │  │   │
│  │  └─────────────┘  └──────────────┘  └──────────────┘  │   │
│  │         │                  │                  │         │   │
│  │         ▼                  ▼                  ▼         │   │
│  │  ┌─────────────────────────────────────────────────┐  │   │
│  │  │         Logic Memory Manager (核心)            │  │   │
│  │  └─────────────────────────────────────────────────┘  │   │
│  │                                                           │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                   │
│  ┌─────────────────────────────────────────────────────────┐   │
│  │            Middleware Stack                              │   │
│  ├─────────────────────────────────────────────────────────┤   │
│  │  LogicMemoryMiddleware (NEW)                            │   │
│  │  - 订阅 EventBus                                         │   │
│  │  - 自动捕获用户交互                                      │   │
│  │  - 注入 Memory 到 System Prompt                          │   │
│  └─────────────────────────────────────────────────────────┘   │
│                                                                   │
└─────────────────────────────────────────────────────────────────┘

          ▲                                     ▲
          │                                     │
          │  应用层自定义                       │  应用层调用
          │  (MemoryType, PatternMatcher)      │  (初始化配置)
          │                                     │

┌─────────────────────────────────────────────────────────────────┐
│                    Application Layer                │
├─────────────────────────────────────────────────────────────────┤
│  - 定义业务相关的 Memory 类型 (WritingPreference, etc.)         │
│  - 实现自定义 PatternMatcher (识别用户修改模式)                 │
│  - 配置 LogicMemoryMiddleware                                   │
└─────────────────────────────────────────────────────────────────┘

// pkg/memory/logic/types.go

// LogicMemory 逻辑记忆（通用结构）
type LogicMemory struct {
    // 基础字段
    ID            string
    Namespace     string  // 租户隔离（user:123, team:456, global）
    Scope         MemoryScope  // Session/User/Global

    // Memory 类型（应用层定义）
    Type          string  // "user_preference", "behavior_pattern", etc.
    Category      string  // 分类（可选）

    // Memory 内容
    Key           string  // 唯一标识（如 "writing_tone_preference"）
    Value         any     // 值（结构化数据）
    Description   string  // 人类可读描述（用于 Prompt 注入）

    // 溯源（复用现有 Provenance）
    Provenance    *MemoryProvenance

    // 统计
    AccessCount   int
    LastAccessed  time.Time

    // 元信息
    Metadata      map[string]any  // 扩展字段
    CreatedAt     time.Time
    UpdatedAt     time.Time
}

// MemoryScope 记忆作用域
type MemoryScope string

const (
    ScopeSession  MemoryScope = "session"  // 单次会话
    ScopeUser     MemoryScope = "user"     // 用户级别
    ScopeGlobal   MemoryScope = "global"   // 全局（跨用户）
)

// pkg/memory/logic/store.go

// LogicMemoryStore 存储接口（类似现有 BackendProtocol）
type LogicMemoryStore interface {
    // 基础 CRUD
    Save(ctx context.Context, memory *LogicMemory) error
    Get(ctx context.Context, namespace, key string) (*LogicMemory, error)
    Delete(ctx context.Context, namespace, key string) error
    List(ctx context.Context, namespace string, filters ...Filter) ([]*LogicMemory, error)

    // 高级查询
    SearchByType(ctx context.Context, namespace, memoryType string) ([]*LogicMemory, error)
    SearchByScope(ctx context.Context, namespace string, scope MemoryScope) ([]*LogicMemory, error)
    GetTopK(ctx context.Context, namespace string, k int, orderBy OrderBy) ([]*LogicMemory, error)

    // 统计
    IncrementAccessCount(ctx context.Context, namespace, key string) error
    GetStats(ctx context.Context, namespace string) (*MemoryStats, error)

    // 生命周期
    Prune(ctx context.Context, criteria PruneCriteria) (int, error)  // 清理低价值 Memory
}

// 内置实现
type PostgreSQLLogicStore struct { /* 基于 PostgreSQL */ }
type RedisLogicStore struct { /* 基于 Redis（简单场景） */ }
type InMemoryLogicStore struct { /* 基于内存（测试用） */ }

// pkg/memory/logic/matcher.go

// PatternMatcher 模式识别接口（应用层实现）
type PatternMatcher interface {
    // 从事件中识别 Memory
    MatchEvent(ctx context.Context, event Event) ([]*LogicMemory, error)

    // 支持的事件类型
    SupportedEventTypes() []string
}

// Event 通用事件结构
type Event struct {
    Type      string         // "user_message", "tool_result", "user_feedback", etc.
    Source    string         // 来源（agent_id, user_id）
    Data      map[string]any // 事件数据
    Timestamp time.Time
}

// 应用层示例：YunJin 的 PatternMatcher
type YunJinPatternMatcher struct {
    // 自定义识别逻辑
}

func (m *YunJinPatternMatcher) MatchEvent(ctx context.Context, event Event) ([]*LogicMemory, error) {
    switch event.Type {
    case "user_revision":
        return m.matchRevisionPattern(event.Data)
    case "user_feedback":
        return m.matchFeedbackPattern(event.Data)
    default:
        return nil, nil
    }
}

// pkg/memory/logic/manager.go

// LogicMemoryManager 核心管理器
type LogicMemoryManager struct {
    store           LogicMemoryStore
    matchers        []PatternMatcher  // 支持多个 Matcher
    provenance      *MemoryProvenance
    consolidation   *ConsolidationEngine  // 复用现有 Consolidation
    confidence      *ConfidenceCalculator // 复用现有 Confidence
}

// RecordMemory 记录新 Memory（主动调用）
func (m *LogicMemoryManager) RecordMemory(ctx context.Context, memory *LogicMemory) error

// ProcessEvent 处理事件，自动识别和记录 Memory（被动触发）
func (m *LogicMemoryManager) ProcessEvent(ctx context.Context, event Event) error

// RetrieveMemories 检索 Memory（用于 Prompt 注入）
func (m *LogicMemoryManager) RetrieveMemories(
    ctx context.Context,
    namespace string,
    filters ...Filter,
) ([]*LogicMemory, error)

// ConsolidateMemories 合并冗余 Memory（定期任务）
func (m *LogicMemoryManager) ConsolidateMemories(ctx context.Context, namespace string) error

// PruneMemories 清理低价值 Memory（定期任务）
func (m *LogicMemoryManager) PruneMemories(ctx context.Context, criteria PruneCriteria) error

// pkg/middleware/logic_memory.go

// LogicMemoryMiddleware Logic Memory 中间件
type LogicMemoryMiddleware struct {
    *BaseMiddleware
    manager      *logic.LogicMemoryManager
    eventBus     *events.EventBus
    config       *LogicMemoryConfig
}

// LogicMemoryConfig 配置
type LogicMemoryConfig struct {
    // 存储配置
    Store            logic.LogicMemoryStore
    Matchers         []logic.PatternMatcher  // 应用层注入

    // 捕获配置
    EnableCapture    bool
    CaptureChannels  []types.AgentChannel  // Progress/Control/Monitor

    // 注入配置
    EnableInjection  bool
    InjectionPoint   string  // "system_prompt", "user_prompt", "both"
    MaxMemories      int     // TopK
    MinConfidence    float64 // 最低置信度

    // 性能配置
    AsyncCapture     bool
    CacheTTL         time.Duration
}

// OnAgentStart Agent 启动时订阅事件
func (m *LogicMemoryMiddleware) OnAgentStart(ctx context.Context, agentID string) error {
    // 订阅 EventBus
    m.eventBus.OnControl("*", m.handleControlEvent)
    m.eventBus.OnMonitor("*", m.handleMonitorEvent)
    // ...
}

// WrapModelCall 注入 Memory 到 Prompt
func (m *LogicMemoryMiddleware) WrapModelCall(next ModelCallFunc) ModelCallFunc {
    return func(ctx context.Context, msgs []types.Message, cfg *types.CallConfig) (types.Message, error) {
        // 1. 检索相关 Memory
        namespace := getNamespaceFromContext(ctx)
        memories, _ := m.manager.RetrieveMemories(ctx, namespace,
            logic.WithTopK(m.config.MaxMemories),
            logic.WithMinConfidence(m.config.MinConfidence),
        )

        // 2. 注入到 System Prompt
        if len(memories) > 0 {
            msgs = m.injectMemories(msgs, memories)
        }

        // 3. 执行原始调用
        return next(ctx, msgs, cfg)
    }
}

// handleControlEvent 处理 Control 事件（用户交互）
func (m *LogicMemoryMiddleware) handleControlEvent(event any) {
    // 转换为通用 Event
    genericEvent := m.convertToGenericEvent(event)

    // 异步处理（不阻塞主流程）
    if m.config.AsyncCapture {
        go m.processEventAsync(genericEvent)
    } else {
        m.manager.ProcessEvent(context.Background(), genericEvent)
    }
}

// 在 Logic Memory Manager 中集成现有 Memory
type LogicMemoryManager struct {
    // 现有 Memory 系统
    textMemory     *memory.Manager
    semanticMemory *memory.SemanticMemory
    workingMemory  *memory.WorkingMemoryManager

    // Logic Memory 专用
    logicStore     LogicMemoryStore
    matchers       []PatternMatcher
}

// 自动同步到 Text Memory
func (m *LogicMemoryManager) RecordMemory(ctx context.Context, mem *LogicMemory) error {
    // 1. 存储到 Logic Store
    err := m.logicStore.Save(ctx, mem)

    // 2. 如果置信度高，同步到 Text Memory
    if mem.Provenance.Confidence > 0.85 {
        markdown := m.formatAsMarkdown(mem)
        m.textMemory.AppendNote(ctx, "/memory/patterns.md", mem.Key, markdown)
    }

    // 3. 索引到 Semantic Memory
    if mem.Description != "" {
        m.semanticMemory.Index(ctx, mem.ID, mem.Description, mem.Metadata())
    }

    return err
}

-- Aster SDK 通用表（应用层可扩展）
CREATE TABLE logic_memories (
    id VARCHAR(64) PRIMARY KEY,
    namespace VARCHAR(255) NOT NULL,  -- user:123, team:456, global
    scope VARCHAR(20) NOT NULL,       -- session/user/global

    type VARCHAR(100) NOT NULL,
    category VARCHAR(100),
    key VARCHAR(255) NOT NULL,
    value JSONB NOT NULL,
    description TEXT,

    -- Provenance (复用现有结构)
    source_type VARCHAR(50),
    confidence DECIMAL(3,2),
    sources JSONB,

    access_count INT DEFAULT 0,
    last_accessed TIMESTAMP,

    metadata JSONB,
    created_at TIMESTAMP NOT NULL,
    updated_at TIMESTAMP NOT NULL,

    UNIQUE INDEX idx_namespace_key (namespace, key),
    INDEX idx_namespace_type (namespace, type),
    INDEX idx_scope (scope),
    INDEX idx_confidence (confidence)
);

// manager.go - 核心管理器
func (m *LogicMemoryManager) ProcessEvent(ctx context.Context, event Event) error {
    // 1. 遍历所有 Matcher
    var allMemories []*LogicMemory
    for _, matcher := range m.matchers {
        if contains(matcher.SupportedEventTypes(), event.Type) {
            memories, err := matcher.MatchEvent(ctx, event)
            if err != nil {
                log.Warnf("Matcher failed: %v", err)
                continue
            }
            allMemories = append(allMemories, memories...)
        }
    }

    // 2. 保存或更新 Memory
    for _, mem := range allMemories {
        existing, err := m.store.Get(ctx, mem.Namespace, mem.Key)
        if err == nil && existing != nil {
            // 更新已有 Memory（提升置信度、累积证据）
            m.mergeMemory(existing, mem)
            m.store.Save(ctx, existing)
        } else {
            // 创建新 Memory
            m.store.Save(ctx, mem)
        }
    }

    return nil
}

// mergeMemory 合并新旧 Memory（提升置信度）
func (m *LogicMemoryManager) mergeMemory(existing, new *LogicMemory) {
    // 增加访问计数
    existing.AccessCount++

    // 提升置信度（最多提升 10%）
    boost := 0.05
    existing.Provenance.Confidence = min(existing.Provenance.Confidence + boost, 1.0)

    // 合并 Value（应用层自定义逻辑）
    // ...

    existing.UpdatedAt = time.Now()
}

// 1. 订阅 EventBus
func (m *LogicMemoryMiddleware) OnAgentStart(ctx context.Context, agentID string) error {
    // 订阅所有通道（根据配置）
    if contains(m.config.CaptureChannels, types.ChannelControl) {
        m.eventBus.OnControl("*", m.handleControlEvent)
    }
    if contains(m.config.CaptureChannels, types.ChannelMonitor) {
        m.eventBus.OnMonitor("*", m.handleMonitorEvent)
    }
    return nil
}

// 2. 注入 Memory 到 Prompt
func (m *LogicMemoryMiddleware) injectMemories(msgs []types.Message, memories []*logic.LogicMemory) []types.Message {
    if len(memories) == 0 {
        return msgs
    }

    // 构建 Memory 注入文本
    var builder strings.Builder
    builder.WriteString("\n\n## User Preferences and Memory\n\n")
    builder.WriteString("Based on past interactions, I've learned:\n\n")

    for i, mem := range memories {
        builder.WriteString(fmt.Sprintf(
            "%d. **%s** (%s): %s (Confidence: %.0f%%)\n",
            i+1, mem.Type, mem.Key, mem.Description, mem.Provenance.Confidence*100,
        ))
    }

    builder.WriteString("\nPlease apply these preferences naturally in your response.\n")

    // 注入到第一个 system message
    for i, msg := range msgs {
        if msg.Role == "system" {
            msgs[i].Content += builder.String()
            break
        }
    }

    return msgs
}

// consolidation.go

// ConsolidateMemories 合并冗余 Memory
func (m *LogicMemoryManager) ConsolidateMemories(ctx context.Context, namespace string) error {
    // 1. 获取所有 Memory
    memories, _ := m.store.List(ctx, namespace)

    // 2. 按类型分组
    grouped := m.groupByType(memories)

    // 3. 对每组执行合并
    for memType, group := range grouped {
        if len(group) < 2 {
            continue
        }

        // 使用现有 ConsolidationEngine（基于相似度）
        merged := m.consolidation.Consolidate(ctx, group)
        for _, mem := range merged {
            m.store.Save(ctx, mem)
        }

        // 删除被合并的 Memory
        for _, oldMem := range group {
            if !contains(merged, oldMem) {
                m.store.Delete(ctx, namespace, oldMem.Key)
            }
        }
    }

    return nil
}

// pruning.go

// PruneCriteria 清理条件
type PruneCriteria struct {
    MinConfidence    float64       // 最低置信度
    MaxAge           time.Duration // 最大年龄
    MinAccessCount   int           // 最少访问次数
    SinceLastAccess  time.Duration // 最后访问时间
}

// PruneMemories 清理低价值 Memory
func (m *LogicMemoryManager) PruneMemories(ctx context.Context, criteria PruneCriteria) (int, error) {
    // 1. 查询符合条件的 Memory
    allMemories, _ := m.store.List(ctx, "")

    // 2. 过滤低价值 Memory
    var toDelete []string
    for _, mem := range allMemories {
        if m.shouldPrune(mem, criteria) {
            toDelete = append(toDelete, mem.Key)
        }
    }

    // 3. 批量删除
    for _, key := range toDelete {
        m.store.Delete(ctx, mem.Namespace, key)
    }

    return len(toDelete), nil
}

// shouldPrune 判断是否应该清理
func (m *LogicMemoryManager) shouldPrune(mem *LogicMemory, criteria PruneCriteria) bool {
    // 置信度过低
    if mem.Provenance.Confidence < criteria.MinConfidence {
        return true
    }

    // 太久未访问
    if time.Since(mem.LastAccessed) > criteria.SinceLastAccess {
        return true
    }

    // 访问次数过少且年龄过大
    if mem.AccessCount < criteria.MinAccessCount && time.Since(mem.CreatedAt) > criteria.MaxAge {
        return true
    }

    return false
}

// metrics.go
var (
    memoryTotal = promauto.NewGaugeVec(
        prometheus.GaugeOpts{
            Name: "logic_memory_total",
            Help: "Total number of logic memories",
        },
        []string{"namespace", "type", "scope"},
    )

    memoryProcessDuration = promauto.NewHistogramVec(
        prometheus.HistogramOpts{
            Name:    "logic_memory_process_duration_seconds",
            Help:    "Time to process event and create memory",
            Buckets: prometheus.DefBuckets,
        },
        []string{"event_type"},
    )

    memoryRetrieveDuration = promauto.NewHistogram(
        prometheus.HistogramOpts{
            Name:    "logic_memory_retrieve_duration_seconds",
            Help:    "Time to retrieve memories",
            Buckets: prometheus.DefBuckets,
        },
    )
)

// pkg/tools/logic_memory_tool.go

// LogicMemoryTool 允许 Agent 主动查询和更新 Memory
type LogicMemoryTool struct {
    manager *logic.LogicMemoryManager
}

func (t *LogicMemoryTool) Definition() types.ToolDefinition {
    return types.ToolDefinition{
        Name: "logic_memory",
        Description: "Query and update logic memories (user preferences, behavior patterns)",
        InputSchema: jsonschema.Object{
            Properties: map[string]jsonschema.Schema{
                "action": {Type: "string", Enum: []string{"list", "get", "update"}},
                "type": {Type: "string"},
                "key": {Type: "string"},
                "value": {Type: "object"},
            },
            Required: []string{"action"},
        },
    }
}

func (t *LogicMemoryTool) Execute(ctx context.Context, input map[string]any) (string, error) {
    action := input["action"].(string)
    namespace := getNamespaceFromContext(ctx)

    switch action {
    case "list":
        memories, _ := t.manager.RetrieveMemories(ctx, namespace)
        return formatMemoriesAsMarkdown(memories), nil
    case "get":
        key := input["key"].(string)
        mem, _ := t.manager.store.Get(ctx, namespace, key)
        return formatMemoryAsMarkdown(mem), nil
    case "update":
        // Agent 主动更新 Memory
        // ...
    }

    return "", nil
}

# Logic Memory Framework

## Overview
介绍 Logic Memory 的设计目标、架构、核心概念

## Quick Start
5 分钟快速开始

## Core Concepts
- Memory Types and Scopes
- PatternMatcher
- Consolidation and Pruning

## API Reference
完整 API 文档

## Integration Guide
如何在应用中集成 Logic Memory

## Best Practices
最佳实践和常见模式

## FAQ
常见问题解答

// examples/logic_memory/basic/main.go

func main() {
    // 1. 创建 Logic Memory Store
    store := logic.NewPostgreSQLStore(db)

    // 2. 实现 PatternMatcher（应用层自定义）
    matcher := &MyPatternMatcher{}

    // 3. 创建 LogicMemoryManager
    manager := logic.NewManager(&logic.ManagerConfig{
        Store:    store,
        Matchers: []logic.PatternMatcher{matcher},
    })

    // 4. 配置 Middleware
    middleware := middleware.NewLogicMemoryMiddleware(&middleware.LogicMemoryConfig{
        Manager:          manager,
        EnableCapture:    true,
        EnableInjection:  true,
        MaxMemories:      5,
        MinConfidence:    0.6,
    })

    // 5. 注册到 Agent
    deps.MiddlewareStack.Add(middleware)

    // 完成！Logic Memory 自动工作
}

// internal/memory/memory_types.go

const (
    TypeWritingTone      = "writing_tone"      // 写作语气偏好
    TypeMaterialSource   = "material_source"   // 素材来源偏好
    TypeStructure        = "structure"         // 结构偏好
    TypeWordChoice       = "word_choice"       // 用词偏好
    TypeTopicSuitability = "topic_suitability" // 主题适配性
)

// WritingTonePreference 写作语气偏好
type WritingTonePreference struct {
    PreferredTone string   // "formal", "casual", "humorous"
    AvoidedPhrases []string // 避免的词汇
    Examples       []RevisionExample
}

// RevisionExample 修改示例
type RevisionExample struct {
    From string
    To   string
    Reason string
}

// internal/memory/pattern_matcher.go

type YunJinPatternMatcher struct {
    // 可选：使用 LLM 辅助识别
    provider provider.Provider
}

func (m *YunJinPatternMatcher) SupportedEventTypes() []string {
    return []string{
        "user_revision",     // 用户修改内容
        "user_feedback",     // 用户评价
        "topic_selection",   // 主题选择
        "material_rejection",// 素材拒绝
    }
}

func (m *YunJinPatternMatcher) MatchEvent(ctx context.Context, event logic.Event) ([]*logic.LogicMemory, error) {
    switch event.Type {
    case "user_revision":
        return m.matchRevisionPattern(ctx, event)
    case "user_feedback":
        return m.matchFeedbackPattern(ctx, event)
    // ...
    }
    return nil, nil
}

// matchRevisionPattern 识别用户修改模式
func (m *YunJinPatternMatcher) matchRevisionPattern(ctx context.Context, event logic.Event) ([]*logic.LogicMemory, error) {
    original := event.Data["original"].(string)
    revised := event.Data["revised"].(string)

    var memories []*logic.LogicMemory

    // 规则 1: 删除书面语
    if m.containsFormalWords(original) && !m.containsFormalWords(revised) {
        mem := &logic.LogicMemory{
            Namespace:   event.Source,
            Scope:       logic.ScopeUser,
            Type:        TypeWritingTone,
            Key:         "casual_tone_preference",
            Value: WritingTonePreference{
                PreferredTone: "casual",
                AvoidedPhrases: m.extractRemovedFormalWords(original, revised),
                Examples: []RevisionExample{{From: original, To: revised}},
            },
            Description: "用户偏好口语化表达，避免使用书面语",
            Provenance: &memory.MemoryProvenance{
                SourceType: memory.SourceUserInput,
                Confidence: 0.70,
            },
        }
        memories = append(memories, mem)
    }

    // 规则 2: 增加 emoji
    // 规则 3: 缩短段落
    // ...

    return memories, nil
}

// 可选：使用 LLM 辅助识别（更准确但更慢）
func (m *YunJinPatternMatcher) matchWithLLM(ctx context.Context, original, revised string) (*logic.LogicMemory, error) {
    prompt := fmt.Sprintf(`
分析用户的修改行为，识别写作偏好。

原文：%s
修改后：%s

请用 JSON 返回：
{
  "type": "...",
  "key": "...",
  "description": "...",
  "confidence": 0.80
}
`, original, revised)

    response, _ := m.provider.CallModel(ctx, []types.Message{{Role: "user", Content: prompt}}, nil)
    // 解析 JSON 并构建 LogicMemory
    // ...
}

// internal/agent/agent_manager.go

func NewAgentManager(config *Config) *AgentManager {
    // 1. 创建 Logic Memory Store
    logicStore := logic.NewPostgreSQLStore(config.DB)

    // 2. 创建 YunJin PatternMatcher
    matcher := memory.NewYunJinPatternMatcher(config.Provider)

    // 3. 创建 LogicMemoryManager
    logicManager := logic.NewManager(&logic.ManagerConfig{
        Store:    logicStore,
        Matchers: []logic.PatternMatcher{matcher},
    })

    // 4. 创建 LogicMemoryMiddleware
    logicMiddleware := middleware.NewLogicMemoryMiddleware(&middleware.LogicMemoryConfig{
        Manager:         logicManager,
        EventBus:        config.EventBus,
        EnableCapture:   true,
        CaptureChannels: []types.AgentChannel{types.ChannelControl, types.ChannelMonitor},
        EnableInjection: true,
        MaxMemories:     5,
        MinConfidence:   0.6,
        AsyncCapture:    true,
        CacheTTL:        time.Hour,
    })

    // 5. 注册到 Middleware Stack
    config.MiddlewareStack.Add(logicMiddleware)

    return &AgentManager{
        // ...
        logicManager: logicManager,
    }
}

// 手动触发事件（可选）
func (m *AgentManager) HandleUserRevision(ctx context.Context, sessionID uint, original, revised string) {
    event := logic.Event{
        Type:   "user_revision",
        Source: fmt.Sprintf("user:%d", m.getUserID(sessionID)),
        Data: map[string]any{
            "session_id": sessionID,
            "original":   original,
            "revised":    revised,
        },
        Timestamp: time.Now(),
    }

    m.logicManager.ProcessEvent(ctx, event)
}

// test/logic_memory_test.go

func TestLogicMemoryE2E(t *testing.T) {
    // 1. 用户第一次创作（生成正式表达）
    session := createSession(userID, "技术文章")
    content := generateContent(session, "介绍 Go 语言特性")
    assert.Contains(t, content, "然而") // 正式语气

    // 2. 用户修改为口语化
    revisedContent := strings.ReplaceAll(content, "然而", "不过")
    handleUserRevision(session.ID, content, revisedContent)

    // 3. 等待 Memory 处理
    time.Sleep(100 * time.Millisecond)

    // 4. 验证 Memory 创建
    memories := getLogicMemories(userID)
    assert.Equal(t, 1, len(memories))
    assert.Equal(t, "casual_tone_preference", memories[0].Key)
    assert.Contains(t, memories[0].Description, "口语化")

    // 5. 用户第二次创作（应该应用 Memory）
    session2 := createSession(userID, "技术文章")
    content2 := generateContent(session2, "介绍 Rust 语言特性")
    assert.NotContains(t, content2, "然而") // 已学习，不再使用正式语气
    assert.Contains(t, content2, "不过")    // 使用口语化表达

    // 6. 验证 Memory 置信度提升
    updatedMemories := getLogicMemories(userID)
    assert.GreaterOrEqual(t, updatedMemories[0].Provenance.Confidence, 0.75)
}