claude-brain 0.15.2 → 0.17.0

package/src/routing/search-engine.ts

@@ -1,475 +1,515 @@
-/**
- * Search Engine
- * Phase 19: Wires all advanced intelligence features into a unified search path.
- *
- * This is the core intelligence layer between the router and raw memory.
- * Provides: hybrid search, semantic caching, temporal filtering, timeouts.
- */
-
-import type { Logger } from 'pino'
-import type { NormalizedResult } from './types'
-import { normalizeSearchResults, normalizePatternResults, normalizeCorrectionResults } from './types'
-import {
-  getMemoryService,
-  getSemanticCacheService,
-  getRetrievalPipeline,
-  getKnowledgeGraphService,
-  getEpisodeService,
-  isServicesInitialized
-} from '@/server/services'
-import { timed } from '@/utils/timing'
-
-/**
- * Wrap a promise with a timeout. Returns fallback if the promise doesn't resolve in time.
- */
-function withTimeout<T>(promise: Promise<T>, ms: number, fallback: T): Promise<T> {
-  return Promise.race([
-    promise,
-    new Promise<T>(resolve => setTimeout(() => resolve(fallback), ms))
-  ])
-}
-
-const SEARCH_TIMEOUT = 5000 // 5s timeout for normal searches
-const INTELLIGENCE_TIMEOUT = 12000 // 12s timeout for bulk analytical features
-
-export class SearchEngine {
-  private logger: Logger
-
-  constructor(logger: Logger) {
-    this.logger = logger.child({ component: 'search-engine' })
-  }
-
-  /**
-   * Sort results so same-project entries come first (safety net for cross-project noise).
-   */
-  private prioritizeProject(results: NormalizedResult[], project?: string): NormalizedResult[] {
-    if (!project || results.length === 0) return results
-    const sameProject = results.filter(r => r.project === project)
-    const otherProject = results.filter(r => r.project !== project)
-    if (sameProject.length > 0) return [...sameProject, ...otherProject]
-    return results
-  }
-
-  /**
-   * Enhanced search — uses hybrid retrieval pipeline when available,
-   * falls back to plain searchRaw().
-   * Wraps with semantic cache for repeated queries.
-   */
-  async enhancedSearch(
-    query: string,
-    options?: { project?: string; limit?: number; minSimilarity?: number }
-  ): Promise<NormalizedResult[]> {
-    return timed('brain:search', () => this._enhancedSearchInner(query, options))
-  }
-
-  private async _enhancedSearchInner(
-    query: string,
-    options?: { project?: string; limit?: number; minSimilarity?: number }
-  ): Promise<NormalizedResult[]> {
-    if (!isServicesInitialized()) return []
-
-    const cacheKey = `search:${query}:${options?.project || ''}:${options?.limit || 5}`
-
-    // Check semantic cache first
-    const cache = getSemanticCacheService()
-    if (cache) {
-      try {
-        const cached = await cache.get(cacheKey)
-        if (cached) {
-          this.logger.debug({ query }, 'Search cache hit')
-          return cached as NormalizedResult[]
-        }
-      } catch {
-        // Cache miss or error, continue
-      }
-    }
-
-    // Try hybrid search via RetrievalPipeline
-    const pipeline = getRetrievalPipeline()
-    if (pipeline) {
-      try {
-        const hybridResults = await withTimeout(
-          pipeline.search(query, {
-            project: options?.project,
-            limit: options?.limit || 5,
-            minSimilarity: options?.minSimilarity || 0.3
-          }),
-          SEARCH_TIMEOUT,
-          []
-        )
-
-        if (hybridResults.length > 0) {
-          const normalized = this.prioritizeProject(hybridResults.map((r: any) => ({
-            id: r.id || '',
-            content: typeof r.content === 'string' ? r.content : (r.document || JSON.stringify(r.content ?? '')),
-            score: r.scores?.final || r.score || r.similarity || 0,
-            source: (r.collection === 'patterns' ? 'pattern' : r.collection === 'corrections' ? 'correction' : 'decision') as const,
-            project: r.metadata?.project || options?.project || '',
-            date: r.metadata?.created_at || '',
-            metadata: r.metadata || {}
-          })), options?.project)
-
-          // Cache results
-          if (cache) {
-            try { await cache.set(cacheKey, normalized) } catch {}
-          }
-          return normalized
-        }
-      } catch (error) {
-        this.logger.debug({ error }, 'Hybrid search failed, falling back to plain search')
-      }
-    }
-
-    // Fallback: plain searchRaw
-    return this.plainSearch(query, options, cache, cacheKey)
-  }
-
-  /**
-   * Plain search using memory.searchRaw() — always available.
-   */
-  async plainSearch(
-    query: string,
-    options?: { project?: string; limit?: number; minSimilarity?: number },
-    cache?: any,
-    cacheKey?: string
-  ): Promise<NormalizedResult[]> {
-    if (!isServicesInitialized()) return []
-
-    const memory = getMemoryService()
-    try {
-      const rawResults = await withTimeout(
-        memory.searchRaw(query, {
-          project: options?.project,
-          limit: options?.limit || 5,
-          minSimilarity: options?.minSimilarity || 0.3
-        }),
-        SEARCH_TIMEOUT,
-        []
-      )
-      const normalized = this.prioritizeProject(normalizeSearchResults(rawResults), options?.project)
-
-      // Cache results
-      if (cache && cacheKey) {
-        try { await cache.set(cacheKey, normalized) } catch {}
-      }
-
-      return normalized
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Search patterns with normalization and timeout
-   */
-  async searchPatterns(
-    query: string,
-    options?: { project?: string; limit?: number; minSimilarity?: number }
-  ): Promise<NormalizedResult[]> {
-    if (!isServicesInitialized()) return []
-    const memory = getMemoryService()
-    try {
-      const results = await withTimeout(
-        memory.searchPatterns(query, {
-          project: options?.project,
-          limit: options?.limit || 3,
-          minSimilarity: options?.minSimilarity || 0.3
-        }),
-        SEARCH_TIMEOUT,
-        []
-      )
-      return normalizePatternResults(results)
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Search corrections with normalization and timeout
-   */
-  async searchCorrections(
-    query: string,
-    options?: { project?: string; limit?: number; minSimilarity?: number }
-  ): Promise<NormalizedResult[]> {
-    if (!isServicesInitialized()) return []
-    const memory = getMemoryService()
-    try {
-      const results = await withTimeout(
-        memory.searchCorrections(query, {
-          project: options?.project,
-          limit: options?.limit || 3,
-          minSimilarity: options?.minSimilarity || 0.3
-        }),
-        SEARCH_TIMEOUT,
-        []
-      )
-      return normalizeCorrectionResults(results)
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Search knowledge graph for related concepts
-   */
-  async searchGraph(query: string, limit: number = 5): Promise<NormalizedResult[]> {
-    try {
-      const kgService = getKnowledgeGraphService()
-      if (!kgService?.search) return []
-
-      const graphResults = kgService.search.search({ query, limit })
-      if (!graphResults?.nodes?.length) return []
-
-      return graphResults.nodes.map((n: any) => ({
-        id: n.id || '',
-        content: `**${n.label || n.name}** (${n.type})${n.properties?.description ? `\n${n.properties.description}` : ''}`,
-        score: graphResults.scores.get(n.id) || 0.5,
-        source: 'graph' as const,
-        project: n.properties?.project || '',
-        date: '',
-        metadata: n.properties || {}
-      }))
-    } catch {
-      return []
-    }
-  }
-
-  /**
-   * Temporal search — parse temporal phrases from query, filter results by date range.
-   * Uses TemporalQueryProcessor when available.
-   */
-  async temporalSearch(
-    query: string,
-    options?: { project?: string; limit?: number }
-  ): Promise<{ results: NormalizedResult[]; cleanedQuery: string }> {
-    if (!isServicesInitialized()) return { results: [], cleanedQuery: query }
-
-    try {
-      // Dynamic import to avoid hard dependency
-      const { TemporalQueryProcessor } = await import('@/intelligence/temporal/query-processor')
-      const processor = new TemporalQueryProcessor(this.logger)
-      const parsed = processor.parse(query)
-
-      if (parsed.intent === 'none') {
-        // No temporal expressions found, use normal search
-        const results = await this.enhancedSearch(query, options)
-        return { results, cleanedQuery: query }
-      }
-
-      // Search with cleaned query (temporal phrases removed)
-      const results = await this.enhancedSearch(parsed.cleaned || query, {
-        ...options,
-        limit: (options?.limit || 5) * 2 // Fetch more since we'll filter by date
-      })
-
-      // Filter results by date range
-      const filtered = results.filter(r => {
-        if (!r.date) return true // Keep results without dates
-        const date = new Date(r.date)
-        if (isNaN(date.getTime())) return true
-        if (parsed.startDate && date < parsed.startDate) return false
-        if (parsed.endDate && date > parsed.endDate) return false
-        return true
-      })
-
-      return {
-        results: filtered.slice(0, options?.limit || 5),
-        cleanedQuery: parsed.cleaned || query
-      }
-    } catch {
-      // TemporalQueryProcessor not available, fall back
-      const results = await this.enhancedSearch(query, options)
-      return { results, cleanedQuery: query }
-    }
-  }
-
-  /**
-   * Build a timeline for a topic/project
-   */
-  async buildTimeline(
-    options?: { project?: string; topic?: string; limit?: number }
-  ): Promise<any | null> {
-    if (!isServicesInitialized()) return null
-
-    try {
-      const memory = getMemoryService()
-      if (!memory.isChromaDBEnabled()) return null
-
-      const { TimelineBuilder } = await import('@/intelligence/temporal/timeline')
-      const builder = new TimelineBuilder(
-        this.logger,
-        memory.chroma.collections,
-        memory.chroma.embeddings
-      )
-      return await withTimeout(
-        builder.buildTimeline(options),
-        SEARCH_TIMEOUT,
-        null
-      )
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Analyze decision evolution for a topic
-   */
-  async analyzeEvolution(
-    topic: string,
-    options?: { project?: string; limit?: number }
-  ): Promise<any | null> {
-    if (!isServicesInitialized()) return null
-
-    try {
-      const memory = getMemoryService()
-      if (!memory.isChromaDBEnabled()) return null
-
-      const { DecisionEvolutionTracker } = await import('@/intelligence/temporal/evolution')
-      const tracker = new DecisionEvolutionTracker(
-        this.logger,
-        memory.chroma.collections,
-        memory.chroma.embeddings
-      )
-      return await withTimeout(
-        tracker.analyzeEvolution(topic, options),
-        INTELLIGENCE_TIMEOUT,
-        null
-      )
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Detect trends
-   */
-  async detectTrends(
-    options?: { project?: string; periodDays?: number; limit?: number }
-  ): Promise<any | null> {
-    if (!isServicesInitialized()) return null
-
-    try {
-      const memory = getMemoryService()
-      if (!memory.isChromaDBEnabled()) return null
-
-      const { TrendDetector } = await import('@/intelligence/temporal/trends')
-      const detector = new TrendDetector(this.logger, memory.chroma.collections)
-      return await withTimeout(
-        detector.detectTrends(options),
-        INTELLIGENCE_TIMEOUT,
-        null
-      )
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Multi-hop chain retrieval for complex questions
-   */
-  async chainSearch(
-    query: string,
-    options?: { project?: string; maxHops?: number }
-  ): Promise<any | null> {
-    if (!isServicesInitialized()) return null
-
-    try {
-      const memory = getMemoryService()
-      if (!memory.isChromaDBEnabled()) return null
-
-      const { ChainRetrieval } = await import('@/intelligence/reasoning/chain-retrieval')
-      const chain = new ChainRetrieval(
-        this.logger,
-        memory.chroma.collections,
-        memory.chroma.embeddings
-      )
-      return await withTimeout(
-        chain.retrieve(query, {
-          maxHops: options?.maxHops || 3,
-          project: options?.project
-        }),
-        INTELLIGENCE_TIMEOUT,
-        null
-      )
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Get recommendations based on context
-   */
-  async getRecommendations(
-    query: string,
-    options?: { project?: string; limit?: number }
-  ): Promise<any | null> {
-    if (!isServicesInitialized()) return null
-
-    try {
-      const memory = getMemoryService()
-      if (!memory.isChromaDBEnabled()) return null
-
-      const { Recommender } = await import('@/intelligence/prediction/recommender')
-      const recommender = new Recommender(
-        this.logger,
-        memory.chroma.collections,
-        memory.chroma.embeddings
-      )
-      return await withTimeout(
-        recommender.getRecommendations(query, {
-          project: options?.project,
-          limit: options?.limit || 5
-        }),
-        INTELLIGENCE_TIMEOUT,
-        null
-      )
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Find cross-project patterns
-   */
-  async findCrossProjectPatterns(
-    options?: { query?: string; minProjects?: number; limit?: number }
-  ): Promise<any | null> {
-    if (!isServicesInitialized()) return null
-
-    try {
-      const memory = getMemoryService()
-      if (!memory.isChromaDBEnabled()) return null
-
-      const { PatternGeneralizer } = await import('@/intelligence/cross-project/generalizer')
-      const generalizer = new PatternGeneralizer(
-        this.logger,
-        memory.chroma.collections,
-        memory.chroma.embeddings
-      )
-      return await withTimeout(
-        generalizer.findCrossProjectPatterns(options),
-        INTELLIGENCE_TIMEOUT,
-        null
-      )
-    } catch {
-      return null
-    }
-  }
-
-  /**
-   * Invalidate cache entries for a project after store/update/delete
-   */
-  invalidateCache(project?: string): void {
-    try {
-      const cache = getSemanticCacheService()
-      if (!cache) return
-      if (project) {
-        cache.invalidateProject(project)
-      } else {
-        cache.clear()
-      }
-    } catch {
-      // Cache not available
-    }
-  }
-}
+/**
+ * Search Engine
+ * Phase 19: Wires all advanced intelligence features into a unified search path.
+ *
+ * This is the core intelligence layer between the router and raw memory.
+ * Provides: hybrid search, semantic caching, temporal filtering, timeouts.
+ */
+
+import type { Logger } from 'pino'
+import type { NormalizedResult } from './types'
+import { normalizeSearchResults, normalizePatternResults, normalizeCorrectionResults } from './types'
+import {
+  getMemoryService,
+  getSemanticCacheService,
+  getRetrievalPipeline,
+  getKnowledgeGraphService,
+  getEpisodeService,
+  isServicesInitialized
+} from '@/server/services'
+import { timed } from '@/utils/timing'
+
+/**
+ * Wrap a promise with a timeout. Returns fallback if the promise doesn't resolve in time.
+ */
+function withTimeout<T>(promise: Promise<T>, ms: number, fallback: T): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>(resolve => setTimeout(() => resolve(fallback), ms))
+  ])
+}
+
+const SEARCH_TIMEOUT = 5000 // 5s timeout for normal searches
+const INTELLIGENCE_TIMEOUT = 12000 // 12s timeout for bulk analytical features
+
+/** Phase 25: Common stop words excluded from keyword boosting */
+const KEYWORD_STOP_WORDS = new Set([
+  'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at', 'to', 'for',
+  'of', 'with', 'by', 'from', 'is', 'it', 'as', 'be', 'was', 'are',
+  'were', 'been', 'has', 'have', 'had', 'do', 'does', 'did', 'will',
+  'would', 'could', 'should', 'may', 'might', 'can', 'shall', 'not',
+  'no', 'nor', 'so', 'up', 'out', 'if', 'about', 'into', 'through',
+  'during', 'before', 'after', 'above', 'below', 'between', 'under',
+  'again', 'further', 'then', 'once', 'here', 'there', 'when', 'where',
+  'why', 'how', 'all', 'each', 'every', 'both', 'few', 'more', 'most',
+  'other', 'some', 'such', 'than', 'too', 'very', 'just', 'because',
+  'what', 'which', 'who', 'whom', 'this', 'that', 'these', 'those',
+  'my', 'your', 'his', 'her', 'its', 'our', 'their', 'me', 'him',
+  'she', 'we', 'they', 'you', 'any', 'also', 'only', 'own', 'same',
+  'don', 'now', 'get', 'got', 'use', 'used', 'using', 'know', 'need',
+  'want', 'like', 'make', 'made', 'think', 'said', 'did', 'does'
+])
+
+export class SearchEngine {
+  private logger: Logger
+
+  constructor(logger: Logger) {
+    this.logger = logger.child({ component: 'search-engine' })
+  }
+
+  /**
+   * Sort results so same-project entries come first (safety net for cross-project noise).
+   */
+  private prioritizeProject(results: NormalizedResult[], project?: string): NormalizedResult[] {
+    if (!project || results.length === 0) return results
+    const sameProject = results.filter(r => r.project === project)
+    const otherProject = results.filter(r => r.project !== project)
+    if (sameProject.length > 0) return [...sameProject, ...otherProject]
+    return results
+  }
+
+  /**
+   * Phase 25: Boost results that contain exact query keywords.
+   * Adds up to +0.15 based on keyword overlap ratio.
+   */
+  private boostKeywordMatches(query: string, results: NormalizedResult[]): NormalizedResult[] {
+    const keywords = query.toLowerCase().split(/\s+/).filter(
+      w => w.length > 2 && !KEYWORD_STOP_WORDS.has(w)
+    )
+    if (keywords.length === 0) return results
+
+    return results.map(r => {
+      const contentLower = r.content.toLowerCase()
+      const matches = keywords.filter(kw => contentLower.includes(kw)).length
+      const overlapRatio = matches / keywords.length
+      const boost = overlapRatio * 0.15
+      return {
+        ...r,
+        score: Math.min(r.score + boost, 1.0)
+      }
+    })
+  }
+
+  /**
+   * Enhanced search — uses hybrid retrieval pipeline when available,
+   * falls back to plain searchRaw().
+   * Wraps with semantic cache for repeated queries.
+   */
+  async enhancedSearch(
+    query: string,
+    options?: { project?: string; limit?: number; minSimilarity?: number }
+  ): Promise<NormalizedResult[]> {
+    return timed('brain:search', () => this._enhancedSearchInner(query, options))
+  }
+
+  private async _enhancedSearchInner(
+    query: string,
+    options?: { project?: string; limit?: number; minSimilarity?: number }
+  ): Promise<NormalizedResult[]> {
+    if (!isServicesInitialized()) return []
+
+    const cacheKey = `search:${query}:${options?.project || 'general'}:${options?.limit || 5}`
+
+    // Check semantic cache first
+    const cache = getSemanticCacheService()
+    if (cache) {
+      try {
+        const cached = await cache.get(cacheKey)
+        if (cached) {
+          this.logger.debug({ query }, 'Search cache hit')
+          return cached as NormalizedResult[]
+        }
+      } catch {
+        // Cache miss or error, continue
+      }
+    }
+
+    // Try hybrid search via RetrievalPipeline
+    const pipeline = getRetrievalPipeline()
+    if (pipeline) {
+      try {
+        const hybridResults = await withTimeout(
+          pipeline.search(query, {
+            project: options?.project,
+            limit: options?.limit || 5,
+            minSimilarity: options?.minSimilarity || 0.3
+          }),
+          SEARCH_TIMEOUT,
+          []
+        )
+
+        if (hybridResults.length > 0) {
+          const normalized = this.boostKeywordMatches(query, this.prioritizeProject(hybridResults.map((r: any) => ({
+            id: r.id || '',
+            content: typeof r.content === 'string' ? r.content : (r.document || JSON.stringify(r.content ?? '')),
+            score: r.scores?.final || r.score || r.similarity || 0,
+            source: (r.collection === 'patterns' ? 'pattern' : r.collection === 'corrections' ? 'correction' : 'decision') as const,
+            project: r.metadata?.project || options?.project || '',
+            date: r.metadata?.created_at || '',
+            metadata: r.metadata || {}
+          })), options?.project))
+
+          // Cache results
+          if (cache) {
+            try { await cache.set(cacheKey, normalized) } catch {}
+          }
+          return normalized
+        }
+      } catch (error) {
+        this.logger.debug({ error }, 'Hybrid search failed, falling back to plain search')
+      }
+    }
+
+    // Fallback: plain searchRaw
+    return this.plainSearch(query, options, cache, cacheKey)
+  }
+
+  /**
+   * Plain search using memory.searchRaw() — always available.
+   */
+  async plainSearch(
+    query: string,
+    options?: { project?: string; limit?: number; minSimilarity?: number },
+    cache?: any,
+    cacheKey?: string
+  ): Promise<NormalizedResult[]> {
+    if (!isServicesInitialized()) return []
+
+    const memory = getMemoryService()
+    try {
+      const rawResults = await withTimeout(
+        memory.searchRaw(query, {
+          project: options?.project,
+          limit: options?.limit || 5,
+          minSimilarity: options?.minSimilarity || 0.3
+        }),
+        SEARCH_TIMEOUT,
+        []
+      )
+      const normalized = this.boostKeywordMatches(query, this.prioritizeProject(normalizeSearchResults(rawResults), options?.project))
+
+      // Cache results
+      if (cache && cacheKey) {
+        try { await cache.set(cacheKey, normalized) } catch {}
+      }
+
+      return normalized
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Search patterns with normalization and timeout
+   */
+  async searchPatterns(
+    query: string,
+    options?: { project?: string; limit?: number; minSimilarity?: number }
+  ): Promise<NormalizedResult[]> {
+    if (!isServicesInitialized()) return []
+    const memory = getMemoryService()
+    try {
+      const results = await withTimeout(
+        memory.searchPatterns(query, {
+          project: options?.project,
+          limit: options?.limit || 3,
+          minSimilarity: options?.minSimilarity || 0.3
+        }),
+        SEARCH_TIMEOUT,
+        []
+      )
+      return normalizePatternResults(results)
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Search corrections with normalization and timeout
+   */
+  async searchCorrections(
+    query: string,
+    options?: { project?: string; limit?: number; minSimilarity?: number }
+  ): Promise<NormalizedResult[]> {
+    if (!isServicesInitialized()) return []
+    const memory = getMemoryService()
+    try {
+      const results = await withTimeout(
+        memory.searchCorrections(query, {
+          project: options?.project,
+          limit: options?.limit || 3,
+          minSimilarity: options?.minSimilarity || 0.3
+        }),
+        SEARCH_TIMEOUT,
+        []
+      )
+      return normalizeCorrectionResults(results)
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Search knowledge graph for related concepts
+   */
+  async searchGraph(query: string, limit: number = 5): Promise<NormalizedResult[]> {
+    try {
+      const kgService = getKnowledgeGraphService()
+      if (!kgService?.search) return []
+
+      const graphResults = kgService.search.search({ query, limit })
+      if (!graphResults?.nodes?.length) return []
+
+      return graphResults.nodes.map((n: any) => ({
+        id: n.id || '',
+        content: `**${n.label || n.name}** (${n.type})${n.properties?.description ? `\n${n.properties.description}` : ''}`,
+        score: graphResults.scores.get(n.id) || 0.5,
+        source: 'graph' as const,
+        project: n.properties?.project || '',
+        date: '',
+        metadata: n.properties || {}
+      }))
+    } catch {
+      return []
+    }
+  }
+
+  /**
+   * Temporal search — parse temporal phrases from query, filter results by date range.
+   * Uses TemporalQueryProcessor when available.
+   */
+  async temporalSearch(
+    query: string,
+    options?: { project?: string; limit?: number }
+  ): Promise<{ results: NormalizedResult[]; cleanedQuery: string }> {
+    if (!isServicesInitialized()) return { results: [], cleanedQuery: query }
+
+    try {
+      // Dynamic import to avoid hard dependency
+      const { TemporalQueryProcessor } = await import('@/intelligence/temporal/query-processor')
+      const processor = new TemporalQueryProcessor(this.logger)
+      const parsed = processor.parse(query)
+
+      if (parsed.intent === 'none') {
+        // No temporal expressions found, use normal search
+        const results = await this.enhancedSearch(query, options)
+        return { results, cleanedQuery: query }
+      }
+
+      // Search with cleaned query (temporal phrases removed)
+      const results = await this.enhancedSearch(parsed.cleaned || query, {
+        ...options,
+        limit: (options?.limit || 5) * 2 // Fetch more since we'll filter by date
+      })
+
+      // Filter results by date range
+      const filtered = results.filter(r => {
+        if (!r.date) return true // Keep results without dates
+        const date = new Date(r.date)
+        if (isNaN(date.getTime())) return true
+        if (parsed.startDate && date < parsed.startDate) return false
+        if (parsed.endDate && date > parsed.endDate) return false
+        return true
+      })
+
+      return {
+        results: filtered.slice(0, options?.limit || 5),
+        cleanedQuery: parsed.cleaned || query
+      }
+    } catch {
+      // TemporalQueryProcessor not available, fall back
+      const results = await this.enhancedSearch(query, options)
+      return { results, cleanedQuery: query }
+    }
+  }
+
+  /**
+   * Build a timeline for a topic/project
+   */
+  async buildTimeline(
+    options?: { project?: string; topic?: string; limit?: number }
+  ): Promise<any | null> {
+    if (!isServicesInitialized()) return null
+
+    try {
+      const memory = getMemoryService()
+      if (!memory.isChromaDBEnabled()) return null
+
+      const { TimelineBuilder } = await import('@/intelligence/temporal/timeline')
+      const builder = new TimelineBuilder(
+        this.logger,
+        memory.chroma.collections,
+        memory.chroma.embeddings
+      )
+      return await withTimeout(
+        builder.buildTimeline(options),
+        SEARCH_TIMEOUT,
+        null
+      )
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Analyze decision evolution for a topic
+   */
+  async analyzeEvolution(
+    topic: string,
+    options?: { project?: string; limit?: number }
+  ): Promise<any | null> {
+    if (!isServicesInitialized()) return null
+
+    try {
+      const memory = getMemoryService()
+      if (!memory.isChromaDBEnabled()) return null
+
+      const { DecisionEvolutionTracker } = await import('@/intelligence/temporal/evolution')
+      const tracker = new DecisionEvolutionTracker(
+        this.logger,
+        memory.chroma.collections,
+        memory.chroma.embeddings
+      )
+      return await withTimeout(
+        tracker.analyzeEvolution(topic, options),
+        INTELLIGENCE_TIMEOUT,
+        null
+      )
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Detect trends
+   */
+  async detectTrends(
+    options?: { project?: string; periodDays?: number; limit?: number }
+  ): Promise<any | null> {
+    if (!isServicesInitialized()) return null
+
+    try {
+      const memory = getMemoryService()
+      if (!memory.isChromaDBEnabled()) return null
+
+      const { TrendDetector } = await import('@/intelligence/temporal/trends')
+      const detector = new TrendDetector(this.logger, memory.chroma.collections)
+      return await withTimeout(
+        detector.detectTrends(options),
+        INTELLIGENCE_TIMEOUT,
+        null
+      )
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Multi-hop chain retrieval for complex questions
+   */
+  async chainSearch(
+    query: string,
+    options?: { project?: string; maxHops?: number }
+  ): Promise<any | null> {
+    if (!isServicesInitialized()) return null
+
+    try {
+      const memory = getMemoryService()
+      if (!memory.isChromaDBEnabled()) return null
+
+      const { ChainRetrieval } = await import('@/intelligence/reasoning/chain-retrieval')
+      const chain = new ChainRetrieval(
+        this.logger,
+        memory.chroma.collections,
+        memory.chroma.embeddings
+      )
+      return await withTimeout(
+        chain.retrieve(query, {
+          maxHops: options?.maxHops || 3,
+          project: options?.project
+        }),
+        INTELLIGENCE_TIMEOUT,
+        null
+      )
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Get recommendations based on context
+   */
+  async getRecommendations(
+    query: string,
+    options?: { project?: string; limit?: number }
+  ): Promise<any | null> {
+    if (!isServicesInitialized()) return null
+
+    try {
+      const memory = getMemoryService()
+      if (!memory.isChromaDBEnabled()) return null
+
+      const { Recommender } = await import('@/intelligence/prediction/recommender')
+      const recommender = new Recommender(
+        this.logger,
+        memory.chroma.collections,
+        memory.chroma.embeddings
+      )
+      return await withTimeout(
+        recommender.getRecommendations(query, {
+          project: options?.project,
+          limit: options?.limit || 5
+        }),
+        INTELLIGENCE_TIMEOUT,
+        null
+      )
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Find cross-project patterns
+   */
+  async findCrossProjectPatterns(
+    options?: { query?: string; minProjects?: number; limit?: number }
+  ): Promise<any | null> {
+    if (!isServicesInitialized()) return null
+
+    try {
+      const memory = getMemoryService()
+      if (!memory.isChromaDBEnabled()) return null
+
+      const { PatternGeneralizer } = await import('@/intelligence/cross-project/generalizer')
+      const generalizer = new PatternGeneralizer(
+        this.logger,
+        memory.chroma.collections,
+        memory.chroma.embeddings
+      )
+      return await withTimeout(
+        generalizer.findCrossProjectPatterns(options),
+        INTELLIGENCE_TIMEOUT,
+        null
+      )
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Invalidate cache entries for a project after store/update/delete
+   */
+  invalidateCache(project?: string): void {
+    try {
+      const cache = getSemanticCacheService()
+      if (!cache) return
+      if (project) {
+        cache.invalidateProject(project)
+      } else {
+        cache.clear()
+      }
+    } catch {
+      // Cache not available
+    }
+  }
+}