claude-brain 0.30.2 → 0.30.3

package/src/memory/chroma/store.ts

@@ -1,747 +1,755 @@
-import { randomUUID } from 'crypto'
-import type { Logger } from 'pino'
-import type { CollectionManager } from './collection-manager'
-import type { MemoryMetadata } from './schemas'
-import type { EmbeddingProvider } from './embeddings'
-import type { SearchResult } from './search'
-
-/**
- * Sanitize metadata for ChromaDB v3.x compatibility.
- * Strips undefined/null values (ChromaDB only accepts string, number, boolean).
- */
-function sanitizeMetadata(metadata: Record<string, any>): Record<string, string | number | boolean> {
-  const clean: Record<string, string | number | boolean> = {}
-  for (const [key, value] of Object.entries(metadata)) {
-    if (value === undefined || value === null) continue
-    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-      clean[key] = value
-    } else if (Array.isArray(value)) {
-      clean[key] = JSON.stringify(value)
-    } else {
-      clean[key] = String(value)
-    }
-  }
-  return clean
-}
-
-export interface StoreDecisionInput {
-  id?: string
-  project: string
-  context: string
-  decision: string
-  reasoning: string
-  alternatives?: string
-  outcome?: string
-  tags?: string[]
-}
-
-export interface StoreMemoryInput {
-  project: string
-  content: string
-  type?: 'fact' | 'preference' | 'constraint' | 'goal' | 'general'
-  source?: string
-  confidence?: number
-  metadata?: Record<string, any>
-}
-
-export interface StoredDecision {
-  id: string
-  decision: string
-  metadata: Record<string, any>
-  distance?: number
-}
-
-export interface StoredMemory {
-  id: string
-  content: string
-  metadata: Record<string, any>
-  distance?: number
-}
-
-export type DecisionStoredCallback = (input: StoreDecisionInput & { id: string }) => void
-
-export class ChromaMemoryStore {
-  private logger: Logger
-  private collections: CollectionManager
-  private embeddings?: EmbeddingProvider
-  private onDecisionStored: DecisionStoredCallback[] = []
-
-  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
-    this.logger = logger.child({ component: 'chroma-memory-store' })
-    this.collections = collections
-    this.embeddings = embeddings
-  }
-
-  addDecisionStoredListener(callback: DecisionStoredCallback): () => void {
-    this.onDecisionStored.push(callback)
-    return () => {
-      const idx = this.onDecisionStored.indexOf(callback)
-      if (idx >= 0) this.onDecisionStored.splice(idx, 1)
-    }
-  }
-
-  /**
-   * Check for duplicate decisions by searching for similar content
-   * Returns existing results if similarity >= threshold
-   */
-  async searchForDuplicates(
-    decision: string,
-    project: string,
-    similarityThreshold: number = 0.9
-  ): Promise<{ id: string; similarity: number }[]> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(decision)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: 3,
-          where: { project: { $eq: project } },
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [decision],
-          nResults: 3,
-          where: { project: { $eq: project } },
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      if (!results.ids || results.ids[0]?.length === 0) {
-        return []
-      }
-
-      const duplicates: { id: string; similarity: number }[] = []
-      const ids = results.ids[0] || []
-      const distances = results.distances?.[0] || []
-
-      for (let i = 0; i < ids.length; i++) {
-        const similarity = 1 - (distances[i] || 0)
-        if (similarity >= similarityThreshold) {
-          duplicates.push({ id: ids[i], similarity })
-        }
-      }
-
-      return duplicates
-    } catch (error) {
-      this.logger.warn({ error }, 'Failed to check for duplicates, proceeding with store')
-      return []
-    }
-  }
-
-  async storeDecision(input: StoreDecisionInput): Promise<string> {
-    // Check for duplicate decisions (similarity > 0.9)
-    const existing = await this.searchForDuplicates(input.decision, input.project, 0.9)
-    const firstDuplicate = existing[0]
-    if (firstDuplicate) {
-      this.logger.info({ existingId: firstDuplicate.id, similarity: firstDuplicate.similarity }, 'Skipping duplicate decision')
-      return firstDuplicate.id
-    }
-
-    const id = input.id || randomUUID()
-    const now = new Date().toISOString()
-
-    const metadata: Record<string, any> = {
-      project: input.project,
-      context: input.context,
-      reasoning: input.reasoning,
-      alternatives: input.alternatives || '',
-      outcome: input.outcome || '',
-      tags: (input.tags || []).join(','),
-      created_at: now,
-      updated_at: now,
-      source: 'manual',
-      decision: input.decision // Include the decision text in metadata
-    }
-
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const embeddings = this.embeddings
-        ? [await this.embeddings.generate(input.decision)]
-        : undefined
-
-      await collection.add({
-        ids: [id],
-        documents: [input.decision],
-        metadatas: [sanitizeMetadata(metadata as Record<string, any>)],
-        ...(embeddings ? { embeddings } : {})
-      })
-
-      // ALSO store in memories collection for unified semantic search
-      try {
-        const memoriesCollection = await this.collections.getMemories()
-        const memoryContent = `Decision: ${input.decision}\nContext: ${input.context}\nReasoning: ${input.reasoning}`
-        const memoryMetadata = {
-          project: input.project,
-          type: 'decision',
-          source: 'remember_decision',
-          confidence: 1.0,
-          created_at: now,
-          updated_at: now,
-          decision_id: id,
-          // Phase 19: Include decision fields so memories collection results
-          // can surface decision content without cross-collection lookup
-          decision: input.decision,
-          reasoning: input.reasoning,
-          context: input.context
-        }
-
-        await memoriesCollection.add({
-          ids: [id], // Use same ID for cross-reference
-          documents: [memoryContent],
-          metadatas: [sanitizeMetadata(memoryMetadata)],
-          ...(embeddings ? { embeddings } : {})
-        })
-
-        this.logger.debug({ id }, 'Decision also stored in memories collection')
-      } catch (memError) {
-        this.logger.warn({ error: memError, id }, 'Failed to store decision in memories collection')
-      }
-
-      this.logger.info(
-        { id, project: input.project },
-        'Decision stored in ChromaDB'
-      )
-
-      // Notify listeners (e.g., knowledge graph builder)
-      for (const callback of this.onDecisionStored) {
-        try {
-          callback({ ...input, id })
-        } catch (callbackError) {
-          this.logger.warn({ error: callbackError }, 'Decision stored callback failed')
-        }
-      }
-
-      return id
-
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store decision')
-      throw error
-    }
-  }
-
-  async storePattern(input: {
-    id?: string
-    project: string
-    pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-    description: string
-    example?: string
-    confidence: number
-    context?: string
-    source?: string
-  }): Promise<string> {
-    const id = input.id || randomUUID()
-    const now = new Date().toISOString()
-
-    const metadata: Record<string, any> = {
-      project: input.project,
-      pattern_type: input.pattern_type,
-      description: input.description,
-      example: input.example || '',
-      confidence: input.confidence,
-      context: input.context || '',
-      created_at: now,
-      updated_at: now,
-      source: input.source || 'manual'
-    }
-
-    try {
-      const collection = await this.collections.getPatterns()
-
-      const embeddings = this.embeddings
-        ? [await this.embeddings.generate(input.description)]
-        : undefined
-
-      await collection.add({
-        ids: [id],
-        documents: [input.description],
-        metadatas: [sanitizeMetadata(metadata)],
-        ...(embeddings ? { embeddings } : {})
-      })
-
-      // ALSO store in memories collection for unified semantic search
-      try {
-        const memoriesCollection = await this.collections.getMemories()
-        const memoryContent = `Pattern (${input.pattern_type}): ${input.description}${input.context ? `\nContext: ${input.context}` : ''}${input.example ? `\nExample: ${input.example}` : ''}`
-        const memoryMetadata = {
-          project: input.project,
-          type: 'pattern',
-          source: 'recognize_pattern',
-          confidence: input.confidence,
-          created_at: now,
-          updated_at: now,
-          pattern_id: id,
-          pattern_type: input.pattern_type
-        }
-
-        await memoriesCollection.add({
-          ids: [id],
-          documents: [memoryContent],
-          metadatas: [sanitizeMetadata(memoryMetadata)],
-          ...(embeddings ? { embeddings } : {})
-        })
-
-        this.logger.debug({ id }, 'Pattern also stored in memories collection')
-      } catch (memError) {
-        this.logger.warn({ error: memError, id }, 'Failed to store pattern in memories collection')
-      }
-
-      this.logger.info({ id, pattern_type: input.pattern_type }, 'Pattern stored in ChromaDB')
-
-      return id
-
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store pattern')
-      throw error
-    }
-  }
-
-  async storeCorrection(input: {
-    id?: string
-    project: string
-    original: string
-    correction: string
-    reasoning: string
-    context?: string
-    confidence: number
-  }): Promise<string> {
-    const id = input.id || randomUUID()
-    const now = new Date().toISOString()
-
-    const metadata: Record<string, any> = {
-      project: input.project,
-      original: input.original,
-      correction: input.correction,
-      reasoning: input.reasoning,
-      context: input.context || '',
-      confidence: input.confidence,
-      created_at: now,
-      updated_at: now,
-      source: 'manual'
-    }
-
-    try {
-      const collection = await this.collections.getCorrections()
-
-      const embeddings = this.embeddings
-        ? [await this.embeddings.generate(input.correction)]
-        : undefined
-
-      await collection.add({
-        ids: [id],
-        documents: [input.correction],
-        metadatas: [sanitizeMetadata(metadata)],
-        ...(embeddings ? { embeddings } : {})
-      })
-
-      // ALSO store in memories collection for unified semantic search
-      try {
-        const memoriesCollection = await this.collections.getMemories()
-        const memoryContent = `Correction: ${input.correction}\nOriginal: ${input.original}\nReasoning: ${input.reasoning}${input.context ? `\nContext: ${input.context}` : ''}`
-        const memoryMetadata = {
-          project: input.project,
-          type: 'correction',
-          source: 'record_correction',
-          confidence: input.confidence,
-          created_at: now,
-          updated_at: now,
-          correction_id: id
-        }
-
-        await memoriesCollection.add({
-          ids: [id],
-          documents: [memoryContent],
-          metadatas: [sanitizeMetadata(memoryMetadata)],
-          ...(embeddings ? { embeddings } : {})
-        })
-
-        this.logger.debug({ id }, 'Correction also stored in memories collection')
-      } catch (memError) {
-        this.logger.warn({ error: memError, id }, 'Failed to store correction in memories collection')
-      }
-
-      this.logger.info({ id, project: input.project }, 'Correction stored in ChromaDB')
-
-      return id
-
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store correction')
-      throw error
-    }
-  }
-
-  async storeMemory(input: StoreMemoryInput): Promise<string> {
-    const id = randomUUID()
-    const now = new Date().toISOString()
-
-    const metadata: MemoryMetadata = {
-      project: input.project,
-      type: input.type || 'general',
-      source: input.source || 'unknown',
-      confidence: input.confidence || 1.0,
-      created_at: now,
-      updated_at: now
-    }
-
-    try {
-      const collection = await this.collections.getMemories()
-
-      const embeddings = this.embeddings
-        ? [await this.embeddings.generate(input.content)]
-        : undefined
-
-      await collection.add({
-        ids: [id],
-        documents: [input.content],
-        metadatas: [sanitizeMetadata(metadata as Record<string, any>)],
-        ...(embeddings ? { embeddings } : {})
-      })
-
-      this.logger.info(
-        { id, project: input.project, type: input.type },
-        'Memory stored in ChromaDB'
-      )
-
-      return id
-
-    } catch (error) {
-      this.logger.error({ error, input }, 'Failed to store memory')
-      throw error
-    }
-  }
-
-  async upsertDecision(id: string, input: StoreDecisionInput): Promise<void> {
-    const now = new Date().toISOString()
-
-    const metadata: Record<string, any> = {
-      project: input.project,
-      context: input.context,
-      reasoning: input.reasoning,
-      alternatives: input.alternatives || '',
-      outcome: input.outcome || '',
-      tags: (input.tags || []).join(','),
-      created_at: now,
-      updated_at: now,
-      source: 'manual'
-    }
-
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const embeddings = this.embeddings
-        ? [await this.embeddings.generate(input.decision)]
-        : undefined
-
-      await collection.upsert({
-        ids: [id],
-        documents: [input.decision],
-        metadatas: [sanitizeMetadata(metadata as Record<string, any>)],
-        ...(embeddings ? { embeddings } : {})
-      })
-
-      this.logger.info({ id }, 'Decision upserted')
-
-    } catch (error) {
-      this.logger.error({ error, id, errorMessage: error instanceof Error ? error.message : String(error) }, 'Failed to upsert decision')
-      throw error
-    }
-  }
-
-  async getDecision(id: string): Promise<StoredDecision | null> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const result = await collection.get({
-        ids: [id],
-        include: ['documents', 'metadatas']
-      })
-
-      if (result.ids.length === 0) {
-        return null
-      }
-
-      return {
-        id: result.ids[0]!,
-        decision: result.documents![0] as string,
-        metadata: result.metadatas![0] as Record<string, any>
-      }
-
-    } catch (error) {
-      this.logger.error({ error, id }, 'Failed to get decision')
-      throw error
-    }
-  }
-
-  async getDecisionsByProject(project: string): Promise<StoredDecision[]> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const result = await collection.get({
-        where: { project },
-        include: ['documents', 'metadatas']
-      })
-
-      return result.ids.map((id, i) => ({
-        id,
-        decision: result.documents![i] as string,
-        metadata: result.metadatas![i] as Record<string, any>
-      }))
-
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get decisions by project')
-      throw error
-    }
-  }
-
-  async deleteDecision(id: string): Promise<void> {
-    try {
-      // Delete from decisions collection
-      const collection = await this.collections.getDecisions()
-      await collection.delete({ ids: [id] })
-
-      // Verify deletion succeeded
-      try {
-        const verify = await collection.get({ ids: [id] })
-        if (verify.ids.length > 0) {
-          this.logger.warn({ id }, 'Decision still exists after delete — retrying')
-          await collection.delete({ ids: [id] })
-        }
-      } catch {
-        // Verification query failed, assume delete succeeded
-      }
-
-      // ALSO delete from memories collection (dual storage uses same ID)
-      try {
-        const memoriesCollection = await this.collections.getMemories()
-        await memoriesCollection.delete({ ids: [id] })
-        this.logger.debug({ id }, 'Decision also deleted from memories collection')
-      } catch {
-        // Memories collection entry may not exist, that's ok
-      }
-
-      this.logger.info({ id }, 'Decision deleted from all collections')
-
-    } catch (error) {
-      this.logger.error({ error, id }, 'Failed to delete decision')
-      throw error
-    }
-  }
-
-  async getAllDecisions(): Promise<StoredDecision[]> {
-    try {
-      const collection = await this.collections.getDecisions()
-
-      const result = await collection.get({
-        include: ['documents', 'metadatas']
-      })
-
-      return result.ids.map((id, i) => ({
-        id,
-        decision: result.documents![i] as string,
-        metadata: result.metadatas![i] as Record<string, any>
-      }))
-
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to get all decisions')
-      throw error
-    }
-  }
-
-  async getPatternsByProject(project: string, options?: {
-    pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-    limit?: number
-  }): Promise<any[]> {
-    try {
-      const collection = await this.collections.getPatterns()
-
-      // Build where clause - handle single vs multiple conditions
-      let where: any
-      if (options?.pattern_type) {
-        // Multiple conditions: use $and operator
-        where = {
-          $and: [
-            { project: { $eq: project } },
-            { pattern_type: { $eq: options.pattern_type } }
-          ]
-        }
-      } else {
-        // Single condition
-        where = { project: { $eq: project } }
-      }
-
-      const result = await collection.get({
-        where,
-        include: ['documents', 'metadatas'],
-        ...(options?.limit ? { limit: options.limit } : {})
-      })
-
-      return result.ids.map((id, i) => ({
-        id,
-        description: result.documents![i] as string,
-        metadata: result.metadatas![i] as Record<string, any>
-      }))
-
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get patterns by project')
-      throw error
-    }
-  }
-
-  async getCorrectionsByProject(project: string, limit: number = 10): Promise<any[]> {
-    try {
-      const collection = await this.collections.getCorrections()
-
-      const result = await collection.get({
-        where: { project },
-        include: ['documents', 'metadatas'],
-        limit
-      })
-
-      return result.ids.map((id, i) => ({
-        id,
-        correction: result.documents![i] as string,
-        metadata: result.metadatas![i] as Record<string, any>
-      }))
-
-    } catch (error) {
-      this.logger.error({ error, project }, 'Failed to get corrections by project')
-      throw error
-    }
-  }
-
-  async searchPatterns(
-    query: string,
-    options: {
-      project?: string
-      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-      limit?: number
-      minSimilarity?: number
-    } = {}
-  ): Promise<SearchResult[]> {
-    const {
-      project,
-      pattern_type,
-      limit = 10,
-      minSimilarity = 0.5
-    } = options
-
-    try {
-      const collection = await this.collections.getPatterns()
-
-      const where: any = {}
-      if (project) {
-        where.project = project
-      }
-      if (pattern_type) {
-        where.pattern_type = pattern_type
-      }
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(query)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where: Object.keys(where).length > 0 ? where : undefined,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [query],
-          nResults: limit,
-          where: Object.keys(where).length > 0 ? where : undefined,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      return this.processResults(results, minSimilarity)
-
-    } catch (error) {
-      this.logger.error({ error, query }, 'Pattern search failed')
-      throw error
-    }
-  }
-
-  async searchCorrections(
-    query: string,
-    options: {
-      project?: string
-      limit?: number
-      minSimilarity?: number
-    } = {}
-  ): Promise<SearchResult[]> {
-    const {
-      project,
-      limit = 10,
-      minSimilarity = 0.5
-    } = options
-
-    try {
-      const collection = await this.collections.getCorrections()
-
-      const where: any = project ? { project } : {}
-
-      let results: any
-
-      if (this.embeddings) {
-        const embedding = await this.embeddings.generate(query)
-        results = await collection.query({
-          queryEmbeddings: [embedding],
-          nResults: limit,
-          where: Object.keys(where).length > 0 ? where : undefined,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      } else {
-        results = await collection.query({
-          queryTexts: [query],
-          nResults: limit,
-          where: Object.keys(where).length > 0 ? where : undefined,
-          include: ['documents', 'metadatas', 'distances']
-        })
-      }
-
-      return this.processResults(results, minSimilarity)
-
-    } catch (error) {
-      this.logger.error({ error, query }, 'Correction search failed')
-      throw error
-    }
-  }
-
-  private processResults(
-    results: any,
-    minSimilarity: number
-  ): SearchResult[] {
-    if (!results.ids || results.ids.length === 0) {
-      return []
-    }
-
-    const processed: SearchResult[] = []
-
-    const ids = results.ids[0] || []
-    const documents = results.documents?.[0] || []
-    const metadatas = results.metadatas?.[0] || []
-    const distances = results.distances?.[0] || []
-
-    for (let i = 0; i < ids.length; i++) {
-      const similarity = 1 - (distances[i] || 0)
-
-      if (similarity >= minSimilarity) {
-        processed.push({
-          id: ids[i],
-          content: documents[i],
-          metadata: metadatas[i],
-          similarity
-        })
-      }
-    }
-
-    return processed.sort((a, b) => b.similarity - a.similarity)
-  }
-}
+import { randomUUID } from 'crypto'
+import type { Logger } from 'pino'
+import type { CollectionManager } from './collection-manager'
+import type { MemoryMetadata } from './schemas'
+import type { EmbeddingProvider } from './embeddings'
+import type { SearchResult } from './search'
+
+/** ChromaDB query result shape */
+interface ChromaQueryResult {
+  ids: string[][]
+  documents?: (string | null)[][]
+  metadatas?: (Record<string, unknown> | null)[][]
+  distances?: number[][]
+}
+
+/**
+ * Sanitize metadata for ChromaDB v3.x compatibility.
+ * Strips undefined/null values (ChromaDB only accepts string, number, boolean).
+ */
+function sanitizeMetadata(metadata: Record<string, unknown>): Record<string, string | number | boolean> {
+  const clean: Record<string, string | number | boolean> = {}
+  for (const [key, value] of Object.entries(metadata)) {
+    if (value === undefined || value === null) continue
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+      clean[key] = value
+    } else if (Array.isArray(value)) {
+      clean[key] = JSON.stringify(value)
+    } else {
+      clean[key] = String(value)
+    }
+  }
+  return clean
+}
+
+export interface StoreDecisionInput {
+  id?: string
+  project: string
+  context: string
+  decision: string
+  reasoning: string
+  alternatives?: string
+  outcome?: string
+  tags?: string[]
+}
+
+export interface StoreMemoryInput {
+  project: string
+  content: string
+  type?: 'fact' | 'preference' | 'constraint' | 'goal' | 'general'
+  source?: string
+  confidence?: number
+  metadata?: Record<string, unknown>
+}
+
+export interface StoredDecision {
+  id: string
+  decision: string
+  metadata: Record<string, unknown>
+  distance?: number
+}
+
+export interface StoredMemory {
+  id: string
+  content: string
+  metadata: Record<string, unknown>
+  distance?: number
+}
+
+export type DecisionStoredCallback = (input: StoreDecisionInput & { id: string }) => void
+
+export class ChromaMemoryStore {
+  private logger: Logger
+  private collections: CollectionManager
+  private embeddings?: EmbeddingProvider
+  private onDecisionStored: DecisionStoredCallback[] = []
+
+  constructor(logger: Logger, collections: CollectionManager, embeddings?: EmbeddingProvider) {
+    this.logger = logger.child({ component: 'chroma-memory-store' })
+    this.collections = collections
+    this.embeddings = embeddings
+  }
+
+  addDecisionStoredListener(callback: DecisionStoredCallback): () => void {
+    this.onDecisionStored.push(callback)
+    return () => {
+      const idx = this.onDecisionStored.indexOf(callback)
+      if (idx >= 0) this.onDecisionStored.splice(idx, 1)
+    }
+  }
+
+  /**
+   * Check for duplicate decisions by searching for similar content
+   * Returns existing results if similarity >= threshold
+   */
+  async searchForDuplicates(
+    decision: string,
+    project: string,
+    similarityThreshold: number = 0.9
+  ): Promise<{ id: string; similarity: number }[]> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      let results: ChromaQueryResult
+
+      if (this.embeddings) {
+        const embedding = await this.embeddings.generate(decision)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: 3,
+          where: { project: { $eq: project } },
+          include: ['documents', 'metadatas', 'distances']
+        }) as unknown as ChromaQueryResult
+      } else {
+        results = await collection.query({
+          queryTexts: [decision],
+          nResults: 3,
+          where: { project: { $eq: project } },
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      if (!results.ids || results.ids[0]?.length === 0) {
+        return []
+      }
+
+      const duplicates: { id: string; similarity: number }[] = []
+      const ids = results.ids[0] || []
+      const distances = results.distances?.[0] || []
+
+      for (let i = 0; i < ids.length; i++) {
+        const similarity = 1 - (distances[i] || 0)
+        if (similarity >= similarityThreshold) {
+          duplicates.push({ id: ids[i], similarity })
+        }
+      }
+
+      return duplicates
+    } catch (error) {
+      this.logger.warn({ error }, 'Failed to check for duplicates, proceeding with store')
+      return []
+    }
+  }
+
+  async storeDecision(input: StoreDecisionInput): Promise<string> {
+    // Check for duplicate decisions (similarity > 0.9)
+    const existing = await this.searchForDuplicates(input.decision, input.project, 0.9)
+    const firstDuplicate = existing[0]
+    if (firstDuplicate) {
+      this.logger.info({ existingId: firstDuplicate.id, similarity: firstDuplicate.similarity }, 'Skipping duplicate decision')
+      return firstDuplicate.id
+    }
+
+    const id = input.id || randomUUID()
+    const now = new Date().toISOString()
+
+    const metadata: Record<string, unknown> = {
+      project: input.project,
+      context: input.context,
+      reasoning: input.reasoning,
+      alternatives: input.alternatives || '',
+      outcome: input.outcome || '',
+      tags: (input.tags || []).join(','),
+      created_at: now,
+      updated_at: now,
+      source: 'manual',
+      decision: input.decision // Include the decision text in metadata
+    }
+
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const embeddings = this.embeddings
+        ? [await this.embeddings.generate(input.decision)]
+        : undefined
+
+      await collection.add({
+        ids: [id],
+        documents: [input.decision],
+        metadatas: [sanitizeMetadata(metadata as Record<string, unknown>)],
+        ...(embeddings ? { embeddings } : {})
+      })
+
+      // ALSO store in memories collection for unified semantic search
+      try {
+        const memoriesCollection = await this.collections.getMemories()
+        const memoryContent = `Decision: ${input.decision}\nContext: ${input.context}\nReasoning: ${input.reasoning}`
+        const memoryMetadata = {
+          project: input.project,
+          type: 'decision',
+          source: 'remember_decision',
+          confidence: 1.0,
+          created_at: now,
+          updated_at: now,
+          decision_id: id,
+          // Phase 19: Include decision fields so memories collection results
+          // can surface decision content without cross-collection lookup
+          decision: input.decision,
+          reasoning: input.reasoning,
+          context: input.context
+        }
+
+        await memoriesCollection.add({
+          ids: [id], // Use same ID for cross-reference
+          documents: [memoryContent],
+          metadatas: [sanitizeMetadata(memoryMetadata)],
+          ...(embeddings ? { embeddings } : {})
+        })
+
+        this.logger.debug({ id }, 'Decision also stored in memories collection')
+      } catch (memError) {
+        this.logger.warn({ error: memError, id }, 'Failed to store decision in memories collection')
+      }
+
+      this.logger.info(
+        { id, project: input.project },
+        'Decision stored in ChromaDB'
+      )
+
+      // Notify listeners (e.g., knowledge graph builder)
+      for (const callback of this.onDecisionStored) {
+        try {
+          callback({ ...input, id })
+        } catch (callbackError) {
+          this.logger.warn({ error: callbackError }, 'Decision stored callback failed')
+        }
+      }
+
+      return id
+
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store decision')
+      throw error
+    }
+  }
+
+  async storePattern(input: {
+    id?: string
+    project: string
+    pattern_type: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+    description: string
+    example?: string
+    confidence: number
+    context?: string
+    source?: string
+  }): Promise<string> {
+    const id = input.id || randomUUID()
+    const now = new Date().toISOString()
+
+    const metadata: Record<string, unknown> = {
+      project: input.project,
+      pattern_type: input.pattern_type,
+      description: input.description,
+      example: input.example || '',
+      confidence: input.confidence,
+      context: input.context || '',
+      created_at: now,
+      updated_at: now,
+      source: input.source || 'manual'
+    }
+
+    try {
+      const collection = await this.collections.getPatterns()
+
+      const embeddings = this.embeddings
+        ? [await this.embeddings.generate(input.description)]
+        : undefined
+
+      await collection.add({
+        ids: [id],
+        documents: [input.description],
+        metadatas: [sanitizeMetadata(metadata)],
+        ...(embeddings ? { embeddings } : {})
+      })
+
+      // ALSO store in memories collection for unified semantic search
+      try {
+        const memoriesCollection = await this.collections.getMemories()
+        const memoryContent = `Pattern (${input.pattern_type}): ${input.description}${input.context ? `\nContext: ${input.context}` : ''}${input.example ? `\nExample: ${input.example}` : ''}`
+        const memoryMetadata = {
+          project: input.project,
+          type: 'pattern',
+          source: 'recognize_pattern',
+          confidence: input.confidence,
+          created_at: now,
+          updated_at: now,
+          pattern_id: id,
+          pattern_type: input.pattern_type
+        }
+
+        await memoriesCollection.add({
+          ids: [id],
+          documents: [memoryContent],
+          metadatas: [sanitizeMetadata(memoryMetadata)],
+          ...(embeddings ? { embeddings } : {})
+        })
+
+        this.logger.debug({ id }, 'Pattern also stored in memories collection')
+      } catch (memError) {
+        this.logger.warn({ error: memError, id }, 'Failed to store pattern in memories collection')
+      }
+
+      this.logger.info({ id, pattern_type: input.pattern_type }, 'Pattern stored in ChromaDB')
+
+      return id
+
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store pattern')
+      throw error
+    }
+  }
+
+  async storeCorrection(input: {
+    id?: string
+    project: string
+    original: string
+    correction: string
+    reasoning: string
+    context?: string
+    confidence: number
+  }): Promise<string> {
+    const id = input.id || randomUUID()
+    const now = new Date().toISOString()
+
+    const metadata: Record<string, unknown> = {
+      project: input.project,
+      original: input.original,
+      correction: input.correction,
+      reasoning: input.reasoning,
+      context: input.context || '',
+      confidence: input.confidence,
+      created_at: now,
+      updated_at: now,
+      source: 'manual'
+    }
+
+    try {
+      const collection = await this.collections.getCorrections()
+
+      const embeddings = this.embeddings
+        ? [await this.embeddings.generate(input.correction)]
+        : undefined
+
+      await collection.add({
+        ids: [id],
+        documents: [input.correction],
+        metadatas: [sanitizeMetadata(metadata)],
+        ...(embeddings ? { embeddings } : {})
+      })
+
+      // ALSO store in memories collection for unified semantic search
+      try {
+        const memoriesCollection = await this.collections.getMemories()
+        const memoryContent = `Correction: ${input.correction}\nOriginal: ${input.original}\nReasoning: ${input.reasoning}${input.context ? `\nContext: ${input.context}` : ''}`
+        const memoryMetadata = {
+          project: input.project,
+          type: 'correction',
+          source: 'record_correction',
+          confidence: input.confidence,
+          created_at: now,
+          updated_at: now,
+          correction_id: id
+        }
+
+        await memoriesCollection.add({
+          ids: [id],
+          documents: [memoryContent],
+          metadatas: [sanitizeMetadata(memoryMetadata)],
+          ...(embeddings ? { embeddings } : {})
+        })
+
+        this.logger.debug({ id }, 'Correction also stored in memories collection')
+      } catch (memError) {
+        this.logger.warn({ error: memError, id }, 'Failed to store correction in memories collection')
+      }
+
+      this.logger.info({ id, project: input.project }, 'Correction stored in ChromaDB')
+
+      return id
+
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store correction')
+      throw error
+    }
+  }
+
+  async storeMemory(input: StoreMemoryInput): Promise<string> {
+    const id = randomUUID()
+    const now = new Date().toISOString()
+
+    const metadata: MemoryMetadata = {
+      project: input.project,
+      type: input.type || 'general',
+      source: input.source || 'unknown',
+      confidence: input.confidence || 1.0,
+      created_at: now,
+      updated_at: now
+    }
+
+    try {
+      const collection = await this.collections.getMemories()
+
+      const embeddings = this.embeddings
+        ? [await this.embeddings.generate(input.content)]
+        : undefined
+
+      await collection.add({
+        ids: [id],
+        documents: [input.content],
+        metadatas: [sanitizeMetadata(metadata as Record<string, unknown>)],
+        ...(embeddings ? { embeddings } : {})
+      })
+
+      this.logger.info(
+        { id, project: input.project, type: input.type },
+        'Memory stored in ChromaDB'
+      )
+
+      return id
+
+    } catch (error) {
+      this.logger.error({ error, input }, 'Failed to store memory')
+      throw error
+    }
+  }
+
+  async upsertDecision(id: string, input: StoreDecisionInput): Promise<void> {
+    const now = new Date().toISOString()
+
+    const metadata: Record<string, unknown> = {
+      project: input.project,
+      context: input.context,
+      reasoning: input.reasoning,
+      alternatives: input.alternatives || '',
+      outcome: input.outcome || '',
+      tags: (input.tags || []).join(','),
+      created_at: now,
+      updated_at: now,
+      source: 'manual'
+    }
+
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const embeddings = this.embeddings
+        ? [await this.embeddings.generate(input.decision)]
+        : undefined
+
+      await collection.upsert({
+        ids: [id],
+        documents: [input.decision],
+        metadatas: [sanitizeMetadata(metadata as Record<string, unknown>)],
+        ...(embeddings ? { embeddings } : {})
+      })
+
+      this.logger.info({ id }, 'Decision upserted')
+
+    } catch (error) {
+      this.logger.error({ error, id, errorMessage: error instanceof Error ? error.message : String(error) }, 'Failed to upsert decision')
+      throw error
+    }
+  }
+
+  async getDecision(id: string): Promise<StoredDecision | null> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const result = await collection.get({
+        ids: [id],
+        include: ['documents', 'metadatas']
+      })
+
+      if (result.ids.length === 0) {
+        return null
+      }
+
+      return {
+        id: result.ids[0]!,
+        decision: result.documents![0] as string,
+        metadata: result.metadatas![0] as Record<string, unknown>
+      }
+
+    } catch (error) {
+      this.logger.error({ error, id }, 'Failed to get decision')
+      throw error
+    }
+  }
+
+  async getDecisionsByProject(project: string): Promise<StoredDecision[]> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const result = await collection.get({
+        where: { project },
+        include: ['documents', 'metadatas']
+      })
+
+      return result.ids.map((id, i) => ({
+        id,
+        decision: result.documents![i] as string,
+        metadata: result.metadatas![i] as Record<string, unknown>
+      }))
+
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get decisions by project')
+      throw error
+    }
+  }
+
+  async deleteDecision(id: string): Promise<void> {
+    try {
+      // Delete from decisions collection
+      const collection = await this.collections.getDecisions()
+      await collection.delete({ ids: [id] })
+
+      // Verify deletion succeeded
+      try {
+        const verify = await collection.get({ ids: [id] })
+        if (verify.ids.length > 0) {
+          this.logger.warn({ id }, 'Decision still exists after delete — retrying')
+          await collection.delete({ ids: [id] })
+        }
+      } catch {
+        // Verification query failed, assume delete succeeded
+      }
+
+      // ALSO delete from memories collection (dual storage uses same ID)
+      try {
+        const memoriesCollection = await this.collections.getMemories()
+        await memoriesCollection.delete({ ids: [id] })
+        this.logger.debug({ id }, 'Decision also deleted from memories collection')
+      } catch {
+        // Memories collection entry may not exist, that's ok
+      }
+
+      this.logger.info({ id }, 'Decision deleted from all collections')
+
+    } catch (error) {
+      this.logger.error({ error, id }, 'Failed to delete decision')
+      throw error
+    }
+  }
+
+  async getAllDecisions(): Promise<StoredDecision[]> {
+    try {
+      const collection = await this.collections.getDecisions()
+
+      const result = await collection.get({
+        include: ['documents', 'metadatas']
+      })
+
+      return result.ids.map((id, i) => ({
+        id,
+        decision: result.documents![i] as string,
+        metadata: result.metadatas![i] as Record<string, unknown>
+      }))
+
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get all decisions')
+      throw error
+    }
+  }
+
+  async getPatternsByProject(project: string, options?: {
+    pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+    limit?: number
+  }): Promise<{ id: string; description: string; metadata: Record<string, unknown> }[]> {
+    try {
+      const collection = await this.collections.getPatterns()
+
+      // Build where clause - handle single vs multiple conditions
+      let where: Record<string, unknown>
+      if (options?.pattern_type) {
+        // Multiple conditions: use $and operator
+        where = {
+          $and: [
+            { project: { $eq: project } },
+            { pattern_type: { $eq: options.pattern_type } }
+          ]
+        }
+      } else {
+        // Single condition
+        where = { project: { $eq: project } }
+      }
+
+      const result = await collection.get({
+        where,
+        include: ['documents', 'metadatas'],
+        ...(options?.limit ? { limit: options.limit } : {})
+      })
+
+      return result.ids.map((id, i) => ({
+        id,
+        description: result.documents![i] as string,
+        metadata: result.metadatas![i] as Record<string, unknown>
+      }))
+
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get patterns by project')
+      throw error
+    }
+  }
+
+  async getCorrectionsByProject(project: string, limit: number = 10): Promise<{ id: string; correction: string; metadata: Record<string, unknown> }[]> {
+    try {
+      const collection = await this.collections.getCorrections()
+
+      const result = await collection.get({
+        where: { project },
+        include: ['documents', 'metadatas'],
+        limit
+      })
+
+      return result.ids.map((id, i) => ({
+        id,
+        correction: result.documents![i] as string,
+        metadata: result.metadatas![i] as Record<string, unknown>
+      }))
+
+    } catch (error) {
+      this.logger.error({ error, project }, 'Failed to get corrections by project')
+      throw error
+    }
+  }
+
+  async searchPatterns(
+    query: string,
+    options: {
+      project?: string
+      pattern_type?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+      limit?: number
+      minSimilarity?: number
+    } = {}
+  ): Promise<SearchResult[]> {
+    const {
+      project,
+      pattern_type,
+      limit = 10,
+      minSimilarity = 0.5
+    } = options
+
+    try {
+      const collection = await this.collections.getPatterns()
+
+      const where: Record<string, unknown> = {}
+      if (project) {
+        where.project = project
+      }
+      if (pattern_type) {
+        where.pattern_type = pattern_type
+      }
+
+      let results: ChromaQueryResult
+
+      if (this.embeddings) {
+        const embedding = await this.embeddings.generate(query)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where: Object.keys(where).length > 0 ? where : undefined,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [query],
+          nResults: limit,
+          where: Object.keys(where).length > 0 ? where : undefined,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      return this.processResults(results, minSimilarity)
+
+    } catch (error) {
+      this.logger.error({ error, query }, 'Pattern search failed')
+      throw error
+    }
+  }
+
+  async searchCorrections(
+    query: string,
+    options: {
+      project?: string
+      limit?: number
+      minSimilarity?: number
+    } = {}
+  ): Promise<SearchResult[]> {
+    const {
+      project,
+      limit = 10,
+      minSimilarity = 0.5
+    } = options
+
+    try {
+      const collection = await this.collections.getCorrections()
+
+      const where: Record<string, unknown> = project ? { project } : {}
+
+      let results: ChromaQueryResult
+
+      if (this.embeddings) {
+        const embedding = await this.embeddings.generate(query)
+        results = await collection.query({
+          queryEmbeddings: [embedding],
+          nResults: limit,
+          where: Object.keys(where).length > 0 ? where : undefined,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      } else {
+        results = await collection.query({
+          queryTexts: [query],
+          nResults: limit,
+          where: Object.keys(where).length > 0 ? where : undefined,
+          include: ['documents', 'metadatas', 'distances']
+        })
+      }
+
+      return this.processResults(results, minSimilarity)
+
+    } catch (error) {
+      this.logger.error({ error, query }, 'Correction search failed')
+      throw error
+    }
+  }
+
+  private processResults(
+    results: ChromaQueryResult,
+    minSimilarity: number
+  ): SearchResult[] {
+    if (!results.ids || results.ids.length === 0) {
+      return []
+    }
+
+    const processed: SearchResult[] = []
+
+    const ids = results.ids[0] || []
+    const documents = results.documents?.[0] || []
+    const metadatas = results.metadatas?.[0] || []
+    const distances = results.distances?.[0] || []
+
+    for (let i = 0; i < ids.length; i++) {
+      const similarity = 1 - (distances[i] || 0)
+
+      if (similarity >= minSimilarity) {
+        processed.push({
+          id: ids[i],
+          content: documents[i],
+          metadata: metadatas[i],
+          similarity
+        })
+      }
+    }
+
+    return processed.sort((a, b) => b.similarity - a.similarity)
+  }
+}