claude-brain 0.14.0 → 0.14.2

package/src/memory/index.ts

@@ -1,582 +1,582 @@
-/**
- * Memory System - Main Module
- * Phase 3: Memory and Embedding System
- *
- * Unified memory system manager that combines all components
- */
-
-import type { Logger } from 'pino'
-import { MemoryDatabase } from './database'
-import { EmbeddingService } from './embeddings'
-import { MemoryStore } from './store'
-import { SemanticSearch } from './search'
-import { MemoryContextBuilder } from './context-builder'
-import type { MemorySystemStats } from './types'
-import { ChromaManager, DEFAULT_CHROMA_CONFIG, getChromaConfigFromEnv, ChromaMigration, type MigrationOptions } from './chroma'
-
-// Re-export all types and classes for external use
-export * from './types'
-export { MemoryDatabase } from './database'
-export { EmbeddingService } from './embeddings'
-export { MemoryStore } from './store'
-export { SemanticSearch } from './search'
-export { MemoryContextBuilder, type ContextOptions } from './context-builder'
-export {
-  embeddingToBuffer,
-  bufferToEmbedding,
-  normalizeEmbedding,
-  euclideanDistance,
-  cosineSimilarity,
-  dotProduct,
-  magnitude,
-  averageEmbeddings,
-  topKSimilar
-} from './embedding-utils'
-
-// Phase 12: Advanced Memory Features
-export { PatternRecognizer, type Pattern } from './patterns'
-export { LearningSystem, type Correction, type Preference, type LearningInsights } from './learning'
-export { KnowledgeExtractor, type ExtractedKnowledge, type ExtractionResult } from './knowledge-extractor'
-
-/**
- * Unified memory system manager
- * Combines database, embeddings, store, search, and context building
- */
-export class MemoryManager {
-  readonly database: MemoryDatabase
-  readonly embeddings: EmbeddingService
-  readonly contextBuilder: MemoryContextBuilder
-  readonly chroma: ChromaManager
-
-  // Store and search are initialized after database is ready
-  private _store: MemoryStore | null = null
-  private _search: SemanticSearch | null = null
-
-  private logger: Logger
-  private initialized: boolean = false
-  private useChromaDB: boolean = true
-  private onDecisionStoredCallbacks: ((input: any) => void)[] = []
-  private onDecisionDeletedCallbacks: ((id: string) => void)[] = []
-
-  constructor(
-    dbPath: string,
-    logger: Logger,
-    useChromaDB: boolean = true,
-    chromaConfig?: any,
-    customEmbeddings?: EmbeddingService
-  ) {
-    this.logger = logger.child({ component: 'memory-manager' })
-    this.useChromaDB = useChromaDB
-
-    this.database = new MemoryDatabase(dbPath, logger)
-    this.embeddings = customEmbeddings || new EmbeddingService(logger)
-    this.contextBuilder = new MemoryContextBuilder(logger)
-
-    const envConfig = getChromaConfigFromEnv()
-    const config = { ...DEFAULT_CHROMA_CONFIG, ...envConfig, ...chromaConfig }
-    this.chroma = new ChromaManager(logger, config)
-  }
-
-  /**
-   * Initialize memory system
-   * Must be called before using store or search
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      this.logger.warn('Memory system already initialized')
-      return
-    }
-
-    try {
-      this.logger.info('Initializing memory system...')
-
-      await this.database.initialize()
-
-      await this.embeddings.initialize()
-
-      const db = this.database.getDb()
-      this._store = new MemoryStore(db, this.embeddings, this.logger)
-      this._search = new SemanticSearch(db, this.embeddings, this.logger)
-
-      if (this.useChromaDB) {
-        try {
-          await this.chroma.initialize()
-          this.logger.info('ChromaDB backend initialized successfully')
-        } catch (error) {
-          this.logger.warn({ error }, 'Failed to initialize ChromaDB, falling back to SQLite backend')
-          this.useChromaDB = false
-        }
-      }
-
-      this.initialized = true
-      this.logger.info('Memory system initialized successfully')
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to initialize memory system')
-      throw error
-    }
-  }
-
-  /**
-   * Get the memory store (throws if not initialized)
-   */
-  get store(): MemoryStore {
-    if (!this._store) {
-      throw new Error('Memory system not initialized. Call initialize() first.')
-    }
-    return this._store
-  }
-
-  /**
-   * Get the semantic search engine (throws if not initialized)
-   */
-  get search(): SemanticSearch {
-    if (!this._search) {
-      throw new Error('Memory system not initialized. Call initialize() first.')
-    }
-    return this._search
-  }
-
-  /**
-   * Check if memory system is initialized
-   */
-  isInitialized(): boolean {
-    return this.initialized
-  }
-
-  close(): void {
-    if (this.useChromaDB) {
-      this.chroma.close()
-    }
-    this.database.close()
-    this._store = null
-    this._search = null
-    this.initialized = false
-    this.logger.info('Memory system closed')
-  }
-
-  /**
-   * Get system statistics
-   */
-  getStats(): MemorySystemStats {
-    if (!this.initialized) {
-      throw new Error('Memory system not initialized')
-    }
-
-    return {
-      database: this.database.getStats(),
-      embeddings: this.embeddings.getCacheStats()
-    }
-  }
-
-  /**
-   * Health check
-   */
-  async healthCheck(): Promise<boolean> {
-    if (!this.initialized) {
-      return false
-    }
-    return this.database.healthCheck()
-  }
-
-  /**
-   * Check if ChromaDB backend is enabled and connected
-   */
-  isChromaDBEnabled(): boolean {
-    return this.useChromaDB
-  }
-
-  /**
-   * Add a listener that fires when a decision is stored (from any backend)
-   */
-  addDecisionStoredListener(callback: (input: any) => void): void {
-    this.onDecisionStoredCallbacks.push(callback)
-    // Also wire to ChromaDB listener if available
-    if (this.useChromaDB) {
-      this.chroma.store.addDecisionStoredListener(callback)
-    }
-  }
-
-  /**
-   * Add a listener that fires when a decision is deleted
-   */
-  addDecisionDeletedListener(callback: (id: string) => void): void {
-    this.onDecisionDeletedCallbacks.push(callback)
-  }
-
-  async rememberDecision(
-    project: string,
-    context: string,
-    decision: string,
-    reasoning: string,
-    options?: { alternatives?: string; tags?: string[] }
-  ): Promise<string> {
-    if (this.useChromaDB) {
-      return this.chroma.store.storeDecision({
-        project,
-        context,
-        decision,
-        reasoning,
-        alternatives: options?.alternatives,
-        tags: options?.tags
-      })
-    }
-    const id = await this.store.storeDecision({
-      project,
-      context,
-      decision,
-      reasoning,
-      alternatives: options?.alternatives,
-      tags: options?.tags
-    })
-    // Notify listeners (e.g., knowledge graph builder) for SQLite path
-    for (const cb of this.onDecisionStoredCallbacks) {
-      try {
-        cb({ project, context, decision, reasoning, alternatives: options?.alternatives, tags: options?.tags, id })
-      } catch {}
-    }
-    return id
-  }
-
-  /**
-   * Get raw search results - routes to ChromaDB when enabled
-   * Use this for internal operations that need raw results
-   */
-  async searchRaw(
-    query: string,
-    options?: { project?: string; limit?: number; minSimilarity?: number }
-  ): Promise<any[]> {
-    if (this.useChromaDB) {
-      const chromaResults = await this.chroma.search.searchDecisions(query, {
-        project: options?.project,
-        limit: options?.limit || 5,
-        minSimilarity: options?.minSimilarity || 0.5
-      })
-      // Transform ChromaDB results to match MemorySearchResult structure
-      // Includes flat `content` field for direct access (Phase 19)
-      return chromaResults.map(r => {
-        const memoryContent = typeof r.content === 'string' ? r.content : JSON.stringify(r.content)
-        const decisionObj = r.metadata.decision ? {
-          id: r.id,
-          project: r.metadata.project || options?.project || 'unknown',
-          context: r.metadata.context || '',
-          decision: r.metadata.decision || memoryContent,
-          reasoning: r.metadata.reasoning || '',
-          alternatives: r.metadata.alternatives_considered || '',
-          tags: r.metadata.tags || [],
-          outcome: r.metadata.outcome,
-          createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date()
-        } : undefined
-
-        return {
-          // Flat fields for direct access (Phase 19)
-          id: r.id,
-          content: decisionObj ? decisionObj.decision : memoryContent,
-          // Nested fields for backward compatibility
-          memory: {
-            id: r.id,
-            project: r.metadata.project || options?.project || 'unknown',
-            content: memoryContent,
-            createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date(),
-            metadata: r.metadata
-          },
-          similarity: r.similarity,
-          decision: decisionObj,
-          metadata: r.metadata
-        }
-      })
-    } else {
-      return await this.search.search(query, {
-        project: options?.project,
-        limit: options?.limit || 5,
-        minSimilarity: options?.minSimilarity || 0.5
-      })
-    }
-  }
-
-  async recallSimilar(
-    query: string,
-    options?: { project?: string; limit?: number; minSimilarity?: number }
-  ): Promise<string> {
-    const results = await this.searchRaw(query, options)
-    return this.contextBuilder.buildDecisionContext(results)
-  }
-
-  async getRecommendations(
-    currentContext: string,
-    project: string,
-    limit: number = 3
-  ): Promise<string> {
-    const results = await this.search.getRecommendations(currentContext, project, limit)
-    return this.contextBuilder.buildRecommendationContext(results)
-  }
-
-  async migrateToChromaDB(options: MigrationOptions = {}): Promise<any> {
-    if (!this.useChromaDB) {
-      throw new Error('ChromaDB is not enabled')
-    }
-
-    const migration = new ChromaMigration(
-      this.logger,
-      this.database.getDb(),
-      this.chroma.store,
-      this.chroma.collections
-    )
-
-    return migration.migrate(options)
-  }
-
-  /**
-   * Store a pattern in memory — routes to ChromaDB or SQLite
-   */
-  async storePattern(input: {
-    project: string
-    pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-    description: string
-    example?: string
-    confidence: number
-    context?: string
-    source?: string
-  }): Promise<string> {
-    if (this.useChromaDB) {
-      return this.chroma.store.storePattern(input)
-    }
-    return this.store.storePattern(input)
-  }
-
-  /**
-   * Store a correction/lesson learned — routes to ChromaDB or SQLite
-   */
-  async storeCorrection(input: {
-    project: string
-    original: string
-    correction: string
-    reasoning: string
-    context?: string
-    confidence: number
-  }): Promise<string> {
-    if (this.useChromaDB) {
-      return this.chroma.store.storeCorrection(input)
-    }
-    return this.store.storeCorrection(input)
-  }
-
-  /**
-   * Get patterns for a project — routes to ChromaDB or SQLite
-   */
-  async getPatterns(
-    project?: string,
-    options?: {
-      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-      limit?: number
-    }
-  ): Promise<any[]> {
-    if (this.useChromaDB) {
-      if (project) {
-        return this.chroma.store.getPatternsByProject(project, options)
-      }
-      return this.chroma.store.searchPatterns('', { limit: options?.limit || 10 })
-    }
-    if (project) {
-      return this.store.getPatternsByProject(project, options)
-    }
-    return this.store.searchPatterns('', { limit: options?.limit || 10 })
-  }
-
-  /**
-   * Get corrections for a project — routes to ChromaDB or SQLite
-   */
-  async getCorrections(
-    project?: string,
-    options?: { limit?: number }
-  ): Promise<any[]> {
-    if (this.useChromaDB) {
-      if (project) {
-        return this.chroma.store.getCorrectionsByProject(project, options?.limit || 10)
-      }
-      return this.chroma.store.searchCorrections('', { limit: options?.limit || 10 })
-    }
-    if (project) {
-      return this.store.getCorrectionsByProject(project, options?.limit || 10)
-    }
-    return this.store.searchCorrections('', { limit: options?.limit || 10 })
-  }
-
-  /**
-   * Fetch all decisions with content — routes to ChromaDB or SQLite
-   * Used by analytical tools that need bulk access to decision data
-   */
-  async fetchAllDecisions(project?: string): Promise<any[]> {
-    if (this.useChromaDB) {
-      try {
-        const collection = await this.chroma.collections.getDecisions()
-        const results = await collection.get({
-          where: project ? { project } : undefined
-        })
-        if (results && results.ids) {
-          return results.ids.map((id: string, i: number) => ({
-            id,
-            content: results.documents?.[i] || '',
-            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
-            project: results.metadatas?.[i]?.project || project || 'unknown',
-            context: results.metadatas?.[i]?.context || '',
-            decision: results.metadatas?.[i]?.decision || results.documents?.[i] || '',
-            reasoning: results.metadatas?.[i]?.reasoning || '',
-            alternatives: results.metadatas?.[i]?.alternatives_considered || '',
-            tags: results.metadatas?.[i]?.tags || []
-          }))
-        }
-        return []
-      } catch (error) {
-        this.logger.warn({ error }, 'ChromaDB fetchAllDecisions failed, falling back to SQLite')
-      }
-    }
-    return this.store.getAllDecisionsWithContent(project)
-  }
-
-  /**
-   * Fetch all patterns with content — routes to ChromaDB or SQLite
-   */
-  async fetchAllPatterns(project?: string): Promise<any[]> {
-    if (this.useChromaDB) {
-      try {
-        const collection = await this.chroma.collections.getPatterns()
-        const results = await collection.get({
-          where: project ? { project } : undefined
-        })
-        if (results && results.ids) {
-          return results.ids.map((id: string, i: number) => ({
-            id,
-            content: results.documents?.[i] || '',
-            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
-            project: results.metadatas?.[i]?.project || project || 'unknown',
-            pattern_type: results.metadatas?.[i]?.pattern_type || '',
-            description: results.metadatas?.[i]?.description || results.documents?.[i] || '',
-            example: results.metadatas?.[i]?.example || '',
-            confidence: results.metadatas?.[i]?.confidence || 0,
-            context: results.metadatas?.[i]?.context || ''
-          }))
-        }
-        return []
-      } catch (error) {
-        this.logger.warn({ error }, 'ChromaDB fetchAllPatterns failed, falling back to SQLite')
-      }
-    }
-    return this.store.getAllPatternsWithContent(project)
-  }
-
-  /**
-   * Fetch all corrections with content — routes to ChromaDB or SQLite
-   */
-  async fetchAllCorrections(project?: string): Promise<any[]> {
-    if (this.useChromaDB) {
-      try {
-        const collection = await this.chroma.collections.getCorrections()
-        const results = await collection.get({
-          where: project ? { project } : undefined
-        })
-        if (results && results.ids) {
-          return results.ids.map((id: string, i: number) => ({
-            id,
-            content: results.documents?.[i] || '',
-            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
-            project: results.metadatas?.[i]?.project || project || 'unknown',
-            original: results.metadatas?.[i]?.original || '',
-            correction: results.metadatas?.[i]?.correction || results.documents?.[i] || '',
-            reasoning: results.metadatas?.[i]?.reasoning || '',
-            context: results.metadatas?.[i]?.context || '',
-            confidence: results.metadatas?.[i]?.confidence || 0
-          }))
-        }
-        return []
-      } catch (error) {
-        this.logger.warn({ error }, 'ChromaDB fetchAllCorrections failed, falling back to SQLite')
-      }
-    }
-    return this.store.getAllCorrectionsWithContent(project)
-  }
-
-  /**
-   * Search patterns by query — routes to ChromaDB or SQLite
-   */
-  async searchPatterns(
-    query: string,
-    options?: {
-      project?: string
-      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-      limit?: number
-      minSimilarity?: number
-    }
-  ): Promise<any[]> {
-    if (this.useChromaDB) {
-      return this.chroma.store.searchPatterns(query, options)
-    }
-    return this.store.searchPatterns(query, options)
-  }
-
-  /**
-   * Search corrections by query — routes to ChromaDB or SQLite
-   */
-  async searchCorrections(
-    query: string,
-    options?: {
-      project?: string
-      limit?: number
-      minSimilarity?: number
-    }
-  ): Promise<any[]> {
-    if (this.useChromaDB) {
-      return this.chroma.store.searchCorrections(query, options)
-    }
-    return this.store.searchCorrections(query, options)
-  }
-
-  /**
-   * Delete a decision by ID — routes to ChromaDB or SQLite
-   */
-  async deleteDecision(id: string): Promise<void> {
-    if (this.useChromaDB) {
-      await this.chroma.store.deleteDecision(id)
-    } else {
-      this.store.deleteMemory(id)
-    }
-
-    // Notify listeners (e.g., knowledge graph builder) about deletion
-    for (const cb of this.onDecisionDeletedCallbacks) {
-      try {
-        cb(id)
-      } catch {}
-    }
-  }
-
-  /**
-   * Update a decision by deleting the old one and storing a new version.
-   * Phase 20: Ensures both ChromaDB and knowledge graph are atomically updated.
-   */
-  async updateDecision(
-    oldId: string,
-    project: string,
-    context: string,
-    decision: string,
-    reasoning: string,
-    options?: { alternatives?: string; tags?: string[] }
-  ): Promise<string> {
-    // Delete old version — fires onDecisionDeletedCallbacks (graph + episode cleanup)
-    try {
-      await this.deleteDecision(oldId)
-      this.logger.debug({ oldId }, 'Old decision deleted for update')
-    } catch (error) {
-      this.logger.warn({ error, oldId }, 'Failed to delete old decision during update, storing new version anyway')
-    }
-    // Store new version — fires onDecisionStoredCallbacks (graph rebuild)
-    const newId = await this.rememberDecision(project, context, decision, reasoning, options)
-    this.logger.debug({ oldId, newId }, 'Decision updated: old deleted, new stored')
-    return newId
-  }
-}
-
-/**
- * Create a memory manager instance
- */
-export function createMemoryManager(dbPath: string, logger: Logger): MemoryManager {
-  return new MemoryManager(dbPath, logger)
-}
+/**
+ * Memory System - Main Module
+ * Phase 3: Memory and Embedding System
+ *
+ * Unified memory system manager that combines all components
+ */
+
+import type { Logger } from 'pino'
+import { MemoryDatabase } from './database'
+import { EmbeddingService } from './embeddings'
+import { MemoryStore } from './store'
+import { SemanticSearch } from './search'
+import { MemoryContextBuilder } from './context-builder'
+import type { MemorySystemStats } from './types'
+import { ChromaManager, DEFAULT_CHROMA_CONFIG, getChromaConfigFromEnv, ChromaMigration, type MigrationOptions } from './chroma'
+
+// Re-export all types and classes for external use
+export * from './types'
+export { MemoryDatabase } from './database'
+export { EmbeddingService } from './embeddings'
+export { MemoryStore } from './store'
+export { SemanticSearch } from './search'
+export { MemoryContextBuilder, type ContextOptions } from './context-builder'
+export {
+  embeddingToBuffer,
+  bufferToEmbedding,
+  normalizeEmbedding,
+  euclideanDistance,
+  cosineSimilarity,
+  dotProduct,
+  magnitude,
+  averageEmbeddings,
+  topKSimilar
+} from './embedding-utils'
+
+// Phase 12: Advanced Memory Features
+export { PatternRecognizer, type Pattern } from './patterns'
+export { LearningSystem, type Correction, type Preference, type LearningInsights } from './learning'
+export { KnowledgeExtractor, type ExtractedKnowledge, type ExtractionResult } from './knowledge-extractor'
+
+/**
+ * Unified memory system manager
+ * Combines database, embeddings, store, search, and context building
+ */
+export class MemoryManager {
+  readonly database: MemoryDatabase
+  readonly embeddings: EmbeddingService
+  readonly contextBuilder: MemoryContextBuilder
+  readonly chroma: ChromaManager
+
+  // Store and search are initialized after database is ready
+  private _store: MemoryStore | null = null
+  private _search: SemanticSearch | null = null
+
+  private logger: Logger
+  private initialized: boolean = false
+  private useChromaDB: boolean = true
+  private onDecisionStoredCallbacks: ((input: any) => void)[] = []
+  private onDecisionDeletedCallbacks: ((id: string) => void)[] = []
+
+  constructor(
+    dbPath: string,
+    logger: Logger,
+    useChromaDB: boolean = true,
+    chromaConfig?: any,
+    customEmbeddings?: EmbeddingService
+  ) {
+    this.logger = logger.child({ component: 'memory-manager' })
+    this.useChromaDB = useChromaDB
+
+    this.database = new MemoryDatabase(dbPath, logger)
+    this.embeddings = customEmbeddings || new EmbeddingService(logger)
+    this.contextBuilder = new MemoryContextBuilder(logger)
+
+    const envConfig = getChromaConfigFromEnv()
+    const config = { ...DEFAULT_CHROMA_CONFIG, ...envConfig, ...chromaConfig }
+    this.chroma = new ChromaManager(logger, config)
+  }
+
+  /**
+   * Initialize memory system
+   * Must be called before using store or search
+   */
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      this.logger.warn('Memory system already initialized')
+      return
+    }
+
+    try {
+      this.logger.info('Initializing memory system...')
+
+      await this.database.initialize()
+
+      await this.embeddings.initialize()
+
+      const db = this.database.getDb()
+      this._store = new MemoryStore(db, this.embeddings, this.logger)
+      this._search = new SemanticSearch(db, this.embeddings, this.logger)
+
+      if (this.useChromaDB) {
+        try {
+          await this.chroma.initialize()
+          this.logger.info('ChromaDB backend initialized successfully')
+        } catch (error) {
+          this.logger.warn({ error }, 'Failed to initialize ChromaDB, falling back to SQLite backend')
+          this.useChromaDB = false
+        }
+      }
+
+      this.initialized = true
+      this.logger.info('Memory system initialized successfully')
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to initialize memory system')
+      throw error
+    }
+  }
+
+  /**
+   * Get the memory store (throws if not initialized)
+   */
+  get store(): MemoryStore {
+    if (!this._store) {
+      throw new Error('Memory system not initialized. Call initialize() first.')
+    }
+    return this._store
+  }
+
+  /**
+   * Get the semantic search engine (throws if not initialized)
+   */
+  get search(): SemanticSearch {
+    if (!this._search) {
+      throw new Error('Memory system not initialized. Call initialize() first.')
+    }
+    return this._search
+  }
+
+  /**
+   * Check if memory system is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized
+  }
+
+  close(): void {
+    if (this.useChromaDB) {
+      this.chroma.close()
+    }
+    this.database.close()
+    this._store = null
+    this._search = null
+    this.initialized = false
+    this.logger.info('Memory system closed')
+  }
+
+  /**
+   * Get system statistics
+   */
+  getStats(): MemorySystemStats {
+    if (!this.initialized) {
+      throw new Error('Memory system not initialized')
+    }
+
+    return {
+      database: this.database.getStats(),
+      embeddings: this.embeddings.getCacheStats()
+    }
+  }
+
+  /**
+   * Health check
+   */
+  async healthCheck(): Promise<boolean> {
+    if (!this.initialized) {
+      return false
+    }
+    return this.database.healthCheck()
+  }
+
+  /**
+   * Check if ChromaDB backend is enabled and connected
+   */
+  isChromaDBEnabled(): boolean {
+    return this.useChromaDB
+  }
+
+  /**
+   * Add a listener that fires when a decision is stored (from any backend)
+   */
+  addDecisionStoredListener(callback: (input: any) => void): void {
+    this.onDecisionStoredCallbacks.push(callback)
+    // Also wire to ChromaDB listener if available
+    if (this.useChromaDB) {
+      this.chroma.store.addDecisionStoredListener(callback)
+    }
+  }
+
+  /**
+   * Add a listener that fires when a decision is deleted
+   */
+  addDecisionDeletedListener(callback: (id: string) => void): void {
+    this.onDecisionDeletedCallbacks.push(callback)
+  }
+
+  async rememberDecision(
+    project: string,
+    context: string,
+    decision: string,
+    reasoning: string,
+    options?: { alternatives?: string; tags?: string[] }
+  ): Promise<string> {
+    if (this.useChromaDB) {
+      return this.chroma.store.storeDecision({
+        project,
+        context,
+        decision,
+        reasoning,
+        alternatives: options?.alternatives,
+        tags: options?.tags
+      })
+    }
+    const id = await this.store.storeDecision({
+      project,
+      context,
+      decision,
+      reasoning,
+      alternatives: options?.alternatives,
+      tags: options?.tags
+    })
+    // Notify listeners (e.g., knowledge graph builder) for SQLite path
+    for (const cb of this.onDecisionStoredCallbacks) {
+      try {
+        cb({ project, context, decision, reasoning, alternatives: options?.alternatives, tags: options?.tags, id })
+      } catch {}
+    }
+    return id
+  }
+
+  /**
+   * Get raw search results - routes to ChromaDB when enabled
+   * Use this for internal operations that need raw results
+   */
+  async searchRaw(
+    query: string,
+    options?: { project?: string; limit?: number; minSimilarity?: number }
+  ): Promise<any[]> {
+    if (this.useChromaDB) {
+      const chromaResults = await this.chroma.search.searchDecisions(query, {
+        project: options?.project,
+        limit: options?.limit || 5,
+        minSimilarity: options?.minSimilarity || 0.5
+      })
+      // Transform ChromaDB results to match MemorySearchResult structure
+      // Includes flat `content` field for direct access (Phase 19)
+      return chromaResults.map(r => {
+        const memoryContent = typeof r.content === 'string' ? r.content : JSON.stringify(r.content)
+        const decisionObj = r.metadata.decision ? {
+          id: r.id,
+          project: r.metadata.project || options?.project || 'unknown',
+          context: r.metadata.context || '',
+          decision: r.metadata.decision || memoryContent,
+          reasoning: r.metadata.reasoning || '',
+          alternatives: r.metadata.alternatives_considered || '',
+          tags: r.metadata.tags || [],
+          outcome: r.metadata.outcome,
+          createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date()
+        } : undefined
+
+        return {
+          // Flat fields for direct access (Phase 19)
+          id: r.id,
+          content: decisionObj ? decisionObj.decision : memoryContent,
+          // Nested fields for backward compatibility
+          memory: {
+            id: r.id,
+            project: r.metadata.project || options?.project || 'unknown',
+            content: memoryContent,
+            createdAt: r.metadata.created_at ? new Date(r.metadata.created_at) : new Date(),
+            metadata: r.metadata
+          },
+          similarity: r.similarity,
+          decision: decisionObj,
+          metadata: r.metadata
+        }
+      })
+    } else {
+      return await this.search.search(query, {
+        project: options?.project,
+        limit: options?.limit || 5,
+        minSimilarity: options?.minSimilarity || 0.5
+      })
+    }
+  }
+
+  async recallSimilar(
+    query: string,
+    options?: { project?: string; limit?: number; minSimilarity?: number }
+  ): Promise<string> {
+    const results = await this.searchRaw(query, options)
+    return this.contextBuilder.buildDecisionContext(results)
+  }
+
+  async getRecommendations(
+    currentContext: string,
+    project: string,
+    limit: number = 3
+  ): Promise<string> {
+    const results = await this.search.getRecommendations(currentContext, project, limit)
+    return this.contextBuilder.buildRecommendationContext(results)
+  }
+
+  async migrateToChromaDB(options: MigrationOptions = {}): Promise<any> {
+    if (!this.useChromaDB) {
+      throw new Error('ChromaDB is not enabled')
+    }
+
+    const migration = new ChromaMigration(
+      this.logger,
+      this.database.getDb(),
+      this.chroma.store,
+      this.chroma.collections
+    )
+
+    return migration.migrate(options)
+  }
+
+  /**
+   * Store a pattern in memory — routes to ChromaDB or SQLite
+   */
+  async storePattern(input: {
+    project: string
+    pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+    description: string
+    example?: string
+    confidence: number
+    context?: string
+    source?: string
+  }): Promise<string> {
+    if (this.useChromaDB) {
+      return this.chroma.store.storePattern(input)
+    }
+    return this.store.storePattern(input)
+  }
+
+  /**
+   * Store a correction/lesson learned — routes to ChromaDB or SQLite
+   */
+  async storeCorrection(input: {
+    project: string
+    original: string
+    correction: string
+    reasoning: string
+    context?: string
+    confidence: number
+  }): Promise<string> {
+    if (this.useChromaDB) {
+      return this.chroma.store.storeCorrection(input)
+    }
+    return this.store.storeCorrection(input)
+  }
+
+  /**
+   * Get patterns for a project — routes to ChromaDB or SQLite
+   */
+  async getPatterns(
+    project?: string,
+    options?: {
+      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+      limit?: number
+    }
+  ): Promise<any[]> {
+    if (this.useChromaDB) {
+      if (project) {
+        return this.chroma.store.getPatternsByProject(project, options)
+      }
+      return this.chroma.store.searchPatterns('', { limit: options?.limit || 10 })
+    }
+    if (project) {
+      return this.store.getPatternsByProject(project, options)
+    }
+    return this.store.searchPatterns('', { limit: options?.limit || 10 })
+  }
+
+  /**
+   * Get corrections for a project — routes to ChromaDB or SQLite
+   */
+  async getCorrections(
+    project?: string,
+    options?: { limit?: number }
+  ): Promise<any[]> {
+    if (this.useChromaDB) {
+      if (project) {
+        return this.chroma.store.getCorrectionsByProject(project, options?.limit || 10)
+      }
+      return this.chroma.store.searchCorrections('', { limit: options?.limit || 10 })
+    }
+    if (project) {
+      return this.store.getCorrectionsByProject(project, options?.limit || 10)
+    }
+    return this.store.searchCorrections('', { limit: options?.limit || 10 })
+  }
+
+  /**
+   * Fetch all decisions with content — routes to ChromaDB or SQLite
+   * Used by analytical tools that need bulk access to decision data
+   */
+  async fetchAllDecisions(project?: string): Promise<any[]> {
+    if (this.useChromaDB) {
+      try {
+        const collection = await this.chroma.collections.getDecisions()
+        const results = await collection.get({
+          where: project ? { project } : undefined
+        })
+        if (results && results.ids) {
+          return results.ids.map((id: string, i: number) => ({
+            id,
+            content: results.documents?.[i] || '',
+            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
+            project: results.metadatas?.[i]?.project || project || 'unknown',
+            context: results.metadatas?.[i]?.context || '',
+            decision: results.metadatas?.[i]?.decision || results.documents?.[i] || '',
+            reasoning: results.metadatas?.[i]?.reasoning || '',
+            alternatives: results.metadatas?.[i]?.alternatives_considered || '',
+            tags: results.metadatas?.[i]?.tags || []
+          }))
+        }
+        return []
+      } catch (error) {
+        this.logger.warn({ error }, 'ChromaDB fetchAllDecisions failed, falling back to SQLite')
+      }
+    }
+    return this.store.getAllDecisionsWithContent(project)
+  }
+
+  /**
+   * Fetch all patterns with content — routes to ChromaDB or SQLite
+   */
+  async fetchAllPatterns(project?: string): Promise<any[]> {
+    if (this.useChromaDB) {
+      try {
+        const collection = await this.chroma.collections.getPatterns()
+        const results = await collection.get({
+          where: project ? { project } : undefined
+        })
+        if (results && results.ids) {
+          return results.ids.map((id: string, i: number) => ({
+            id,
+            content: results.documents?.[i] || '',
+            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
+            project: results.metadatas?.[i]?.project || project || 'unknown',
+            pattern_type: results.metadatas?.[i]?.pattern_type || '',
+            description: results.metadatas?.[i]?.description || results.documents?.[i] || '',
+            example: results.metadatas?.[i]?.example || '',
+            confidence: results.metadatas?.[i]?.confidence || 0,
+            context: results.metadatas?.[i]?.context || ''
+          }))
+        }
+        return []
+      } catch (error) {
+        this.logger.warn({ error }, 'ChromaDB fetchAllPatterns failed, falling back to SQLite')
+      }
+    }
+    return this.store.getAllPatternsWithContent(project)
+  }
+
+  /**
+   * Fetch all corrections with content — routes to ChromaDB or SQLite
+   */
+  async fetchAllCorrections(project?: string): Promise<any[]> {
+    if (this.useChromaDB) {
+      try {
+        const collection = await this.chroma.collections.getCorrections()
+        const results = await collection.get({
+          where: project ? { project } : undefined
+        })
+        if (results && results.ids) {
+          return results.ids.map((id: string, i: number) => ({
+            id,
+            content: results.documents?.[i] || '',
+            date: results.metadatas?.[i]?.created_at || new Date().toISOString(),
+            project: results.metadatas?.[i]?.project || project || 'unknown',
+            original: results.metadatas?.[i]?.original || '',
+            correction: results.metadatas?.[i]?.correction || results.documents?.[i] || '',
+            reasoning: results.metadatas?.[i]?.reasoning || '',
+            context: results.metadatas?.[i]?.context || '',
+            confidence: results.metadatas?.[i]?.confidence || 0
+          }))
+        }
+        return []
+      } catch (error) {
+        this.logger.warn({ error }, 'ChromaDB fetchAllCorrections failed, falling back to SQLite')
+      }
+    }
+    return this.store.getAllCorrectionsWithContent(project)
+  }
+
+  /**
+   * Search patterns by query — routes to ChromaDB or SQLite
+   */
+  async searchPatterns(
+    query: string,
+    options?: {
+      project?: string
+      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+      limit?: number
+      minSimilarity?: number
+    }
+  ): Promise<any[]> {
+    if (this.useChromaDB) {
+      return this.chroma.store.searchPatterns(query, options)
+    }
+    return this.store.searchPatterns(query, options)
+  }
+
+  /**
+   * Search corrections by query — routes to ChromaDB or SQLite
+   */
+  async searchCorrections(
+    query: string,
+    options?: {
+      project?: string
+      limit?: number
+      minSimilarity?: number
+    }
+  ): Promise<any[]> {
+    if (this.useChromaDB) {
+      return this.chroma.store.searchCorrections(query, options)
+    }
+    return this.store.searchCorrections(query, options)
+  }
+
+  /**
+   * Delete a decision by ID — routes to ChromaDB or SQLite
+   */
+  async deleteDecision(id: string): Promise<void> {
+    if (this.useChromaDB) {
+      await this.chroma.store.deleteDecision(id)
+    } else {
+      this.store.deleteMemory(id)
+    }
+
+    // Notify listeners (e.g., knowledge graph builder) about deletion
+    for (const cb of this.onDecisionDeletedCallbacks) {
+      try {
+        cb(id)
+      } catch {}
+    }
+  }
+
+  /**
+   * Update a decision by deleting the old one and storing a new version.
+   * Phase 20: Ensures both ChromaDB and knowledge graph are atomically updated.
+   */
+  async updateDecision(
+    oldId: string,
+    project: string,
+    context: string,
+    decision: string,
+    reasoning: string,
+    options?: { alternatives?: string; tags?: string[] }
+  ): Promise<string> {
+    // Delete old version — fires onDecisionDeletedCallbacks (graph + episode cleanup)
+    try {
+      await this.deleteDecision(oldId)
+      this.logger.debug({ oldId }, 'Old decision deleted for update')
+    } catch (error) {
+      this.logger.warn({ error, oldId }, 'Failed to delete old decision during update, storing new version anyway')
+    }
+    // Store new version — fires onDecisionStoredCallbacks (graph rebuild)
+    const newId = await this.rememberDecision(project, context, decision, reasoning, options)
+    this.logger.debug({ oldId, newId }, 'Decision updated: old deleted, new stored')
+    return newId
+  }
+}
+
+/**
+ * Create a memory manager instance
+ */
+export function createMemoryManager(dbPath: string, logger: Logger): MemoryManager {
+  return new MemoryManager(dbPath, logger)
+}