claude-brain 0.14.2 → 0.14.4

package/src/automation/phase12-manager.ts

@@ -1,456 +1,456 @@
-/**
- * Phase 12 Manager
- * Advanced Memory & Intelligent Automation
- *
- * Orchestrates all Phase 12 features:
- * - Pattern Recognition
- * - Learning System
- * - Knowledge Extraction
- * - Auto-Context Loading
- * - Decision Detection
- * - Proactive Recall
- */
-
-import type { Logger } from 'pino'
-import type { VaultManager } from '@/vault'
-import type { MemoryManager } from '@/memory'
-import type { ContextManager } from '@/context'
-import { PatternRecognizer, type Pattern } from '@/memory/patterns'
-import { LearningSystem, type LearningInsights } from '@/memory/learning'
-import { KnowledgeExtractor, type ExtractedKnowledge } from '@/memory/knowledge-extractor'
-import {
-  ProjectDetector,
-  AutoContextLoader,
-  DecisionDetector,
-  ProactiveRecallEngine,
-  type DetectedProject,
-  type DetectedDecision,
-  type RecallResult
-} from '@/automation'
-
-export interface Phase12Config {
-  /**
-   * Enable automatic context loading on startup
-   * @default true
-   */
-  autoLoadContext: boolean
-
-  /**
-   * Enable automatic decision detection and saving
-   * @default true
-   */
-  autoDetectDecisions: boolean
-
-  /**
-   * Enable proactive memory recall
-   * @default true
-   */
-  enableProactiveRecall: boolean
-
-  /**
-   * Minimum confidence for auto-saving decisions
-   * @default 0.7
-   */
-  decisionConfidenceThreshold: number
-
-  /**
-   * Enable pattern analysis on startup
-   * @default false
-   */
-  analyzePatternsonStartup: boolean
-
-  /**
-   * Enable knowledge extraction from messages
-   * @default true
-   */
-  enableKnowledgeExtraction: boolean
-}
-
-const DEFAULT_CONFIG: Phase12Config = {
-  autoLoadContext: true,
-  autoDetectDecisions: true,
-  enableProactiveRecall: true,
-  decisionConfidenceThreshold: 0.7,
-  analyzePatternsonStartup: false,
-  enableKnowledgeExtraction: true
-}
-
-export interface MessageProcessingResult {
-  recalledMemories?: RecallResult
-  detectedDecision?: DetectedDecision
-  extractedKnowledge?: ExtractedKnowledge[]
-  detectedProject?: DetectedProject
-  decisionSaved?: boolean
-  decisionId?: string
-}
-
-export interface Phase12Stats {
-  patterns: {
-    total: number
-    byType: Record<string, number>
-  }
-  learning: LearningInsights
-  automation: {
-    contextLoaded: boolean
-    currentProject: string | null
-    recallStats: {
-      totalRecalls: number
-      successfulRecalls: number
-      averageRelevance: number
-    }
-  }
-}
-
-export class Phase12Manager {
-  private logger: Logger
-  private config: Phase12Config
-  private initialized = false
-
-  // Advanced Memory
-  public readonly patterns: PatternRecognizer
-  public readonly learning: LearningSystem
-  public readonly knowledge: KnowledgeExtractor
-
-  // Intelligent Automation
-  public readonly projectDetector: ProjectDetector
-  public readonly autoContext: AutoContextLoader
-  public readonly decisionDetector: DecisionDetector
-  public readonly proactiveRecall: ProactiveRecallEngine
-
-  constructor(
-    logger: Logger,
-    vault: VaultManager,
-    memory: MemoryManager,
-    context: ContextManager,
-    config: Partial<Phase12Config> = {}
-  ) {
-    this.logger = logger.child({ component: 'phase12-manager' })
-    this.config = { ...DEFAULT_CONFIG, ...config }
-
-    // Initialize advanced memory features
-    this.patterns = new PatternRecognizer(logger, memory)
-    this.learning = new LearningSystem(logger, memory)
-    this.knowledge = new KnowledgeExtractor(logger, memory)
-
-    // Initialize intelligent automation
-    this.projectDetector = new ProjectDetector(logger, vault)
-    this.autoContext = new AutoContextLoader(
-      logger,
-      context,
-      this.projectDetector
-    )
-    this.decisionDetector = new DecisionDetector(logger, memory)
-    this.proactiveRecall = new ProactiveRecallEngine(logger, memory)
-
-    this.logger.info(
-      { config: this.config },
-      'Phase 12 Manager created'
-    )
-  }
-
-  /**
-   * Initialize all Phase 12 features
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      this.logger.warn('Phase 12 already initialized')
-      return
-    }
-
-    this.logger.info('Initializing Phase 12 features...')
-
-    try {
-      // Start auto-context loader
-      if (this.config.autoLoadContext) {
-        await this.autoContext.initialize()
-        this.logger.info('Auto-context loader initialized')
-      }
-
-      // Run initial pattern analysis if enabled
-      if (this.config.analyzePatternsonStartup) {
-        const patterns = await this.patterns.analyzePatterns()
-        this.logger.info(
-          { patternCount: patterns.length },
-          'Initial pattern analysis complete'
-        )
-      }
-
-      this.initialized = true
-      this.logger.info('Phase 12 initialization complete')
-    } catch (error) {
-      this.logger.error({ error }, 'Phase 12 initialization failed')
-      throw error
-    }
-  }
-
-  /**
-   * Check if Phase 12 is initialized
-   */
-  isInitialized(): boolean {
-    return this.initialized
-  }
-
-  /**
-   * Process incoming message with all Phase 12 features
-   */
-  async processMessage(
-    message: string,
-    project?: string
-  ): Promise<MessageProcessingResult> {
-    const results: MessageProcessingResult = {}
-
-    // Use detected project if not provided
-    const targetProject = project || this.autoContext.getCurrentProject() || undefined
-
-    // 1. Proactive recall
-    if (this.config.enableProactiveRecall) {
-      if (this.proactiveRecall.shouldRecall(message)) {
-        results.recalledMemories = await this.proactiveRecall.recall(
-          message,
-          targetProject
-        ) || undefined
-      }
-    }
-
-    // 2. Decision detection
-    if (this.config.autoDetectDecisions && targetProject) {
-      const decision = this.decisionDetector.detectDecision(message, targetProject)
-
-      if (decision && decision.confidence >= this.config.decisionConfidenceThreshold) {
-        results.detectedDecision = decision
-
-        // Auto-save if confidence is high enough
-        const decisionId = await this.decisionDetector.autoSaveDecision(
-          decision,
-          targetProject
-        )
-
-        if (decisionId) {
-          results.decisionSaved = true
-          results.decisionId = decisionId
-        }
-      }
-    }
-
-    // 3. Knowledge extraction
-    if (this.config.enableKnowledgeExtraction) {
-      const extracted = await this.knowledge.extractFromConversation(
-        message,
-        targetProject
-      )
-
-      if (extracted.knowledge.length > 0) {
-        results.extractedKnowledge = extracted.knowledge
-      }
-    }
-
-    // Log processing results
-    if (Object.keys(results).length > 0) {
-      this.logger.debug(
-        {
-          hasRecall: !!results.recalledMemories,
-          hasDecision: !!results.detectedDecision,
-          knowledgeCount: results.extractedKnowledge?.length || 0,
-          decisionSaved: results.decisionSaved
-        },
-        'Message processed with Phase 12 features'
-      )
-    }
-
-    return results
-  }
-
-  /**
-   * Process outgoing response for decisions
-   * Call this with Claude's responses to detect and save decisions
-   */
-  async processResponse(
-    response: string,
-    project?: string
-  ): Promise<MessageProcessingResult> {
-    const results: MessageProcessingResult = {}
-    const targetProject = project || this.autoContext.getCurrentProject() || undefined
-
-    // Decision detection on responses (Claude's decisions)
-    if (this.config.autoDetectDecisions && targetProject) {
-      const decision = this.decisionDetector.detectDecision(response, targetProject)
-
-      if (decision && decision.confidence >= this.config.decisionConfidenceThreshold) {
-        results.detectedDecision = decision
-
-        const decisionId = await this.decisionDetector.autoSaveDecision(
-          decision,
-          targetProject
-        )
-
-        if (decisionId) {
-          results.decisionSaved = true
-          results.decisionId = decisionId
-          this.logger.info(
-            { decisionId, project: targetProject },
-            'Decision auto-saved from response'
-          )
-        }
-      }
-    }
-
-    // Knowledge extraction from responses
-    if (this.config.enableKnowledgeExtraction) {
-      const extracted = await this.knowledge.extractFromConversation(
-        response,
-        targetProject
-      )
-
-      if (extracted.knowledge.length > 0) {
-        results.extractedKnowledge = extracted.knowledge
-      }
-    }
-
-    return results
-  }
-
-  /**
-   * Get proactively recalled context for a query
-   */
-  async getRecalledContext(query: string, project?: string): Promise<string | null> {
-    const result = await this.proactiveRecall.recall(
-      query,
-      project || this.autoContext.getCurrentProject() || undefined
-    )
-
-    return result?.formattedContext || null
-  }
-
-  /**
-   * Get relevant patterns for a query
-   */
-  async getRelevantPatterns(query: string): Promise<Pattern[]> {
-    return this.patterns.getRelevantPatterns(query)
-  }
-
-  /**
-   * Record a correction for learning
-   */
-  async recordCorrection(
-    original: string,
-    corrected: string,
-    reasoning: string,
-    project?: string
-  ): Promise<string> {
-    const targetProject = project || this.autoContext.getCurrentProject() || 'global'
-    return this.learning.recordCorrection(original, corrected, reasoning, targetProject)
-  }
-
-  /**
-   * Get comprehensive Phase 12 statistics
-   */
-  getStats(): Phase12Stats {
-    const allPatterns = this.patterns.getAllPatterns()
-    const patternsByType: Record<string, number> = {}
-
-    for (const pattern of allPatterns) {
-      patternsByType[pattern.type] = (patternsByType[pattern.type] || 0) + 1
-    }
-
-    const recallStats = this.proactiveRecall.getStats()
-
-    return {
-      patterns: {
-        total: allPatterns.length,
-        byType: patternsByType
-      },
-      learning: this.learning.getLearningInsights(),
-      automation: {
-        contextLoaded: this.autoContext.getCurrentContext() !== undefined,
-        currentProject: this.autoContext.getCurrentProject(),
-        recallStats: {
-          totalRecalls: recallStats.totalRecalls,
-          successfulRecalls: recallStats.successfulRecalls,
-          averageRelevance: recallStats.averageRelevance
-        }
-      }
-    }
-  }
-
-  /**
-   * Get formatted status report
-   */
-  getStatusReport(): string {
-    const stats = this.getStats()
-    const parts: string[] = []
-
-    parts.push('# Phase 12 Status Report\n')
-
-    // Current project
-    parts.push('## Current Context')
-    if (stats.automation.currentProject) {
-      parts.push(`- **Project:** ${stats.automation.currentProject}`)
-      parts.push(`- **Context Loaded:** Yes`)
-    } else {
-      parts.push('- **Project:** Not detected (use smart_context to load project context)')
-      parts.push('- **Context Loaded:** No')
-    }
-    parts.push('')
-
-    // Pattern analysis
-    parts.push('## Pattern Analysis')
-    parts.push(`- **Total Patterns:** ${stats.patterns.total}`)
-    if (stats.patterns.total === 0) {
-      parts.push('  *No patterns stored yet. Use `recognize_pattern` to document reusable solutions.*')
-    } else {
-      for (const [type, count] of Object.entries(stats.patterns.byType)) {
-        parts.push(`  - ${type}: ${count}`)
-      }
-    }
-    parts.push('')
-
-    // Learning system
-    parts.push('## Learning System')
-    parts.push(`- **Total Corrections:** ${stats.learning.correctionCount}`)
-    if (stats.learning.correctionCount === 0) {
-      parts.push('  *No corrections recorded yet. Use `record_correction` to document lessons learned.*')
-    }
-    parts.push(`- **Categories Improved:** ${stats.learning.categoriesImproved.join(', ') || 'None'}`)
-    if (stats.learning.preferences.length > 0) {
-      parts.push('- **Top Preferences:**')
-      for (const pref of stats.learning.preferences.slice(0, 3)) {
-        parts.push(`  - ${pref.category}: ${Math.round(pref.strength * 100)}% confidence`)
-      }
-    }
-    parts.push('')
-
-    // Proactive recall
-    parts.push('## Proactive Recall')
-    parts.push(`- **Total Recalls:** ${stats.automation.recallStats.totalRecalls}`)
-    parts.push(`- **Successful:** ${stats.automation.recallStats.successfulRecalls}`)
-    const successRate = stats.automation.recallStats.totalRecalls > 0
-      ? Math.round((stats.automation.recallStats.successfulRecalls / stats.automation.recallStats.totalRecalls) * 100)
-      : 0
-    parts.push(`- **Success Rate:** ${successRate}%`)
-    parts.push(`- **Average Relevance:** ${Math.round(stats.automation.recallStats.averageRelevance * 100)}%`)
-
-    if (stats.automation.recallStats.totalRecalls === 0) {
-      parts.push('\n*Proactive recall activates automatically when you ask questions or request recommendations.*')
-    }
-
-    return parts.join('\n')
-  }
-
-  /**
-   * Cleanup and reset Phase 12
-   */
-  cleanup(): void {
-    this.autoContext.clearAllContexts()
-    this.patterns.clearPatterns()
-    this.learning.clearLearning()
-    this.proactiveRecall.resetStats()
-    this.initialized = false
-    this.logger.info('Phase 12 cleaned up')
-  }
-}
-
-// Re-export types
-export type { Pattern } from '@/memory/patterns'
-export type { Correction, Preference, LearningInsights } from '@/memory/learning'
-export type { ExtractedKnowledge, ExtractionResult } from '@/memory/knowledge-extractor'
-export type { DetectedProject, DetectedDecision, RecallResult } from '@/automation'
+/**
+ * Phase 12 Manager
+ * Advanced Memory & Intelligent Automation
+ *
+ * Orchestrates all Phase 12 features:
+ * - Pattern Recognition
+ * - Learning System
+ * - Knowledge Extraction
+ * - Auto-Context Loading
+ * - Decision Detection
+ * - Proactive Recall
+ */
+
+import type { Logger } from 'pino'
+import type { VaultManager } from '@/vault'
+import type { MemoryManager } from '@/memory'
+import type { ContextManager } from '@/context'
+import { PatternRecognizer, type Pattern } from '@/memory/patterns'
+import { LearningSystem, type LearningInsights } from '@/memory/learning'
+import { KnowledgeExtractor, type ExtractedKnowledge } from '@/memory/knowledge-extractor'
+import {
+  ProjectDetector,
+  AutoContextLoader,
+  DecisionDetector,
+  ProactiveRecallEngine,
+  type DetectedProject,
+  type DetectedDecision,
+  type RecallResult
+} from '@/automation'
+
+export interface Phase12Config {
+  /**
+   * Enable automatic context loading on startup
+   * @default true
+   */
+  autoLoadContext: boolean
+
+  /**
+   * Enable automatic decision detection and saving
+   * @default true
+   */
+  autoDetectDecisions: boolean
+
+  /**
+   * Enable proactive memory recall
+   * @default true
+   */
+  enableProactiveRecall: boolean
+
+  /**
+   * Minimum confidence for auto-saving decisions
+   * @default 0.7
+   */
+  decisionConfidenceThreshold: number
+
+  /**
+   * Enable pattern analysis on startup
+   * @default false
+   */
+  analyzePatternsonStartup: boolean
+
+  /**
+   * Enable knowledge extraction from messages
+   * @default true
+   */
+  enableKnowledgeExtraction: boolean
+}
+
+const DEFAULT_CONFIG: Phase12Config = {
+  autoLoadContext: true,
+  autoDetectDecisions: true,
+  enableProactiveRecall: true,
+  decisionConfidenceThreshold: 0.7,
+  analyzePatternsonStartup: false,
+  enableKnowledgeExtraction: true
+}
+
+export interface MessageProcessingResult {
+  recalledMemories?: RecallResult
+  detectedDecision?: DetectedDecision
+  extractedKnowledge?: ExtractedKnowledge[]
+  detectedProject?: DetectedProject
+  decisionSaved?: boolean
+  decisionId?: string
+}
+
+export interface Phase12Stats {
+  patterns: {
+    total: number
+    byType: Record<string, number>
+  }
+  learning: LearningInsights
+  automation: {
+    contextLoaded: boolean
+    currentProject: string | null
+    recallStats: {
+      totalRecalls: number
+      successfulRecalls: number
+      averageRelevance: number
+    }
+  }
+}
+
+export class Phase12Manager {
+  private logger: Logger
+  private config: Phase12Config
+  private initialized = false
+
+  // Advanced Memory
+  public readonly patterns: PatternRecognizer
+  public readonly learning: LearningSystem
+  public readonly knowledge: KnowledgeExtractor
+
+  // Intelligent Automation
+  public readonly projectDetector: ProjectDetector
+  public readonly autoContext: AutoContextLoader
+  public readonly decisionDetector: DecisionDetector
+  public readonly proactiveRecall: ProactiveRecallEngine
+
+  constructor(
+    logger: Logger,
+    vault: VaultManager,
+    memory: MemoryManager,
+    context: ContextManager,
+    config: Partial<Phase12Config> = {}
+  ) {
+    this.logger = logger.child({ component: 'phase12-manager' })
+    this.config = { ...DEFAULT_CONFIG, ...config }
+
+    // Initialize advanced memory features
+    this.patterns = new PatternRecognizer(logger, memory)
+    this.learning = new LearningSystem(logger, memory)
+    this.knowledge = new KnowledgeExtractor(logger, memory)
+
+    // Initialize intelligent automation
+    this.projectDetector = new ProjectDetector(logger, vault)
+    this.autoContext = new AutoContextLoader(
+      logger,
+      context,
+      this.projectDetector
+    )
+    this.decisionDetector = new DecisionDetector(logger, memory)
+    this.proactiveRecall = new ProactiveRecallEngine(logger, memory)
+
+    this.logger.info(
+      { config: this.config },
+      'Phase 12 Manager created'
+    )
+  }
+
+  /**
+   * Initialize all Phase 12 features
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      this.logger.warn('Phase 12 already initialized')
+      return
+    }
+
+    this.logger.info('Initializing Phase 12 features...')
+
+    try {
+      // Start auto-context loader
+      if (this.config.autoLoadContext) {
+        await this.autoContext.initialize()
+        this.logger.info('Auto-context loader initialized')
+      }
+
+      // Run initial pattern analysis if enabled
+      if (this.config.analyzePatternsonStartup) {
+        const patterns = await this.patterns.analyzePatterns()
+        this.logger.info(
+          { patternCount: patterns.length },
+          'Initial pattern analysis complete'
+        )
+      }
+
+      this.initialized = true
+      this.logger.info('Phase 12 initialization complete')
+    } catch (error) {
+      this.logger.error({ error }, 'Phase 12 initialization failed')
+      throw error
+    }
+  }
+
+  /**
+   * Check if Phase 12 is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized
+  }
+
+  /**
+   * Process incoming message with all Phase 12 features
+   */
+  async processMessage(
+    message: string,
+    project?: string
+  ): Promise<MessageProcessingResult> {
+    const results: MessageProcessingResult = {}
+
+    // Use detected project if not provided
+    const targetProject = project || this.autoContext.getCurrentProject() || undefined
+
+    // 1. Proactive recall
+    if (this.config.enableProactiveRecall) {
+      if (this.proactiveRecall.shouldRecall(message)) {
+        results.recalledMemories = await this.proactiveRecall.recall(
+          message,
+          targetProject
+        ) || undefined
+      }
+    }
+
+    // 2. Decision detection
+    if (this.config.autoDetectDecisions && targetProject) {
+      const decision = this.decisionDetector.detectDecision(message, targetProject)
+
+      if (decision && decision.confidence >= this.config.decisionConfidenceThreshold) {
+        results.detectedDecision = decision
+
+        // Auto-save if confidence is high enough
+        const decisionId = await this.decisionDetector.autoSaveDecision(
+          decision,
+          targetProject
+        )
+
+        if (decisionId) {
+          results.decisionSaved = true
+          results.decisionId = decisionId
+        }
+      }
+    }
+
+    // 3. Knowledge extraction
+    if (this.config.enableKnowledgeExtraction) {
+      const extracted = await this.knowledge.extractFromConversation(
+        message,
+        targetProject
+      )
+
+      if (extracted.knowledge.length > 0) {
+        results.extractedKnowledge = extracted.knowledge
+      }
+    }
+
+    // Log processing results
+    if (Object.keys(results).length > 0) {
+      this.logger.debug(
+        {
+          hasRecall: !!results.recalledMemories,
+          hasDecision: !!results.detectedDecision,
+          knowledgeCount: results.extractedKnowledge?.length || 0,
+          decisionSaved: results.decisionSaved
+        },
+        'Message processed with Phase 12 features'
+      )
+    }
+
+    return results
+  }
+
+  /**
+   * Process outgoing response for decisions
+   * Call this with Claude's responses to detect and save decisions
+   */
+  async processResponse(
+    response: string,
+    project?: string
+  ): Promise<MessageProcessingResult> {
+    const results: MessageProcessingResult = {}
+    const targetProject = project || this.autoContext.getCurrentProject() || undefined
+
+    // Decision detection on responses (Claude's decisions)
+    if (this.config.autoDetectDecisions && targetProject) {
+      const decision = this.decisionDetector.detectDecision(response, targetProject)
+
+      if (decision && decision.confidence >= this.config.decisionConfidenceThreshold) {
+        results.detectedDecision = decision
+
+        const decisionId = await this.decisionDetector.autoSaveDecision(
+          decision,
+          targetProject
+        )
+
+        if (decisionId) {
+          results.decisionSaved = true
+          results.decisionId = decisionId
+          this.logger.info(
+            { decisionId, project: targetProject },
+            'Decision auto-saved from response'
+          )
+        }
+      }
+    }
+
+    // Knowledge extraction from responses
+    if (this.config.enableKnowledgeExtraction) {
+      const extracted = await this.knowledge.extractFromConversation(
+        response,
+        targetProject
+      )
+
+      if (extracted.knowledge.length > 0) {
+        results.extractedKnowledge = extracted.knowledge
+      }
+    }
+
+    return results
+  }
+
+  /**
+   * Get proactively recalled context for a query
+   */
+  async getRecalledContext(query: string, project?: string): Promise<string | null> {
+    const result = await this.proactiveRecall.recall(
+      query,
+      project || this.autoContext.getCurrentProject() || undefined
+    )
+
+    return result?.formattedContext || null
+  }
+
+  /**
+   * Get relevant patterns for a query
+   */
+  async getRelevantPatterns(query: string): Promise<Pattern[]> {
+    return this.patterns.getRelevantPatterns(query)
+  }
+
+  /**
+   * Record a correction for learning
+   */
+  async recordCorrection(
+    original: string,
+    corrected: string,
+    reasoning: string,
+    project?: string
+  ): Promise<string> {
+    const targetProject = project || this.autoContext.getCurrentProject() || 'global'
+    return this.learning.recordCorrection(original, corrected, reasoning, targetProject)
+  }
+
+  /**
+   * Get comprehensive Phase 12 statistics
+   */
+  getStats(): Phase12Stats {
+    const allPatterns = this.patterns.getAllPatterns()
+    const patternsByType: Record<string, number> = {}
+
+    for (const pattern of allPatterns) {
+      patternsByType[pattern.type] = (patternsByType[pattern.type] || 0) + 1
+    }
+
+    const recallStats = this.proactiveRecall.getStats()
+
+    return {
+      patterns: {
+        total: allPatterns.length,
+        byType: patternsByType
+      },
+      learning: this.learning.getLearningInsights(),
+      automation: {
+        contextLoaded: this.autoContext.getCurrentContext() !== undefined,
+        currentProject: this.autoContext.getCurrentProject(),
+        recallStats: {
+          totalRecalls: recallStats.totalRecalls,
+          successfulRecalls: recallStats.successfulRecalls,
+          averageRelevance: recallStats.averageRelevance
+        }
+      }
+    }
+  }
+
+  /**
+   * Get formatted status report
+   */
+  getStatusReport(): string {
+    const stats = this.getStats()
+    const parts: string[] = []
+
+    parts.push('# Phase 12 Status Report\n')
+
+    // Current project
+    parts.push('## Current Context')
+    if (stats.automation.currentProject) {
+      parts.push(`- **Project:** ${stats.automation.currentProject}`)
+      parts.push(`- **Context Loaded:** Yes`)
+    } else {
+      parts.push('- **Project:** Not detected (use smart_context to load project context)')
+      parts.push('- **Context Loaded:** No')
+    }
+    parts.push('')
+
+    // Pattern analysis
+    parts.push('## Pattern Analysis')
+    parts.push(`- **Total Patterns:** ${stats.patterns.total}`)
+    if (stats.patterns.total === 0) {
+      parts.push('  *No patterns stored yet. Use `recognize_pattern` to document reusable solutions.*')
+    } else {
+      for (const [type, count] of Object.entries(stats.patterns.byType)) {
+        parts.push(`  - ${type}: ${count}`)
+      }
+    }
+    parts.push('')
+
+    // Learning system
+    parts.push('## Learning System')
+    parts.push(`- **Total Corrections:** ${stats.learning.correctionCount}`)
+    if (stats.learning.correctionCount === 0) {
+      parts.push('  *No corrections recorded yet. Use `record_correction` to document lessons learned.*')
+    }
+    parts.push(`- **Categories Improved:** ${stats.learning.categoriesImproved.join(', ') || 'None'}`)
+    if (stats.learning.preferences.length > 0) {
+      parts.push('- **Top Preferences:**')
+      for (const pref of stats.learning.preferences.slice(0, 3)) {
+        parts.push(`  - ${pref.category}: ${Math.round(pref.strength * 100)}% confidence`)
+      }
+    }
+    parts.push('')
+
+    // Proactive recall
+    parts.push('## Proactive Recall')
+    parts.push(`- **Total Recalls:** ${stats.automation.recallStats.totalRecalls}`)
+    parts.push(`- **Successful:** ${stats.automation.recallStats.successfulRecalls}`)
+    const successRate = stats.automation.recallStats.totalRecalls > 0
+      ? Math.round((stats.automation.recallStats.successfulRecalls / stats.automation.recallStats.totalRecalls) * 100)
+      : 0
+    parts.push(`- **Success Rate:** ${successRate}%`)
+    parts.push(`- **Average Relevance:** ${Math.round(stats.automation.recallStats.averageRelevance * 100)}%`)
+
+    if (stats.automation.recallStats.totalRecalls === 0) {
+      parts.push('\n*Proactive recall activates automatically when you ask questions or request recommendations.*')
+    }
+
+    return parts.join('\n')
+  }
+
+  /**
+   * Cleanup and reset Phase 12
+   */
+  cleanup(): void {
+    this.autoContext.clearAllContexts()
+    this.patterns.clearPatterns()
+    this.learning.clearLearning()
+    this.proactiveRecall.resetStats()
+    this.initialized = false
+    this.logger.info('Phase 12 cleaned up')
+  }
+}
+
+// Re-export types
+export type { Pattern } from '@/memory/patterns'
+export type { Correction, Preference, LearningInsights } from '@/memory/learning'
+export type { ExtractedKnowledge, ExtractionResult } from '@/memory/knowledge-extractor'
+export type { DetectedProject, DetectedDecision, RecallResult } from '@/automation'