claude-brain 0.30.2 → 0.30.3

package/src/routing/entity-extractor.ts

@@ -1,454 +1,454 @@
-/**
- * Brain Entity Extractor
- * Phase 16: Extracts structured data from natural language messages
- * for the unified brain() tool routing
- */
-
-import { getVaultService, isServicesInitialized } from '@/server/services'
-
-// Reuse phrase lists from decision detector
-const DECISION_PHRASES = [
-  'i recommend',
-  'you should use',
-  'the best approach',
-  'i suggest',
-  'better to use',
-  'prefer using',
-  'go with',
-  'choose',
-  'instead of',
-  'the right choice',
-  'decided to',
-  "let's use",
-  'we will use',
-  'the solution is',
-  'implement using',
-  'going with',
-  'switching to',
-  'adopting',
-  'we chose',
-  'the plan is to'
-]
-
-const REASONING_PHRASES = [
-  'because',
-  'since',
-  'due to',
-  'as it',
-  'which provides',
-  'this allows',
-  'this ensures',
-  'given that',
-  'considering',
-  'the reason is',
-  'this way'
-]
-
-const ALTERNATIVE_PHRASES = [
-  'instead of',
-  'rather than',
-  'over',
-  ' vs ',
-  'compared to',
-  'unlike',
-  'as opposed to'
-]
-
-// Compact tech dictionary for entity extraction (most common technologies)
-// Full dictionary is in knowledge/entity-extractor.ts — we use a subset for speed
-const COMMON_TECH: Set<string> = new Set([
-  'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'ruby', 'php', 'swift', 'kotlin',
-  'react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'remix', 'astro', 'solid',
-  'express', 'fastify', 'hono', 'nestjs', 'django', 'flask', 'fastapi', 'rails', 'spring',
-  'mongodb', 'redis', 'postgresql', 'postgres', 'mysql', 'sqlite', 'dynamodb', 'firebase', 'supabase',
-  'prisma', 'drizzle', 'typeorm', 'sequelize', 'chromadb', 'pinecone',
-  'docker', 'kubernetes', 'aws', 'gcp', 'azure', 'vercel', 'netlify',
-  'webpack', 'vite', 'esbuild', 'bun', 'deno', 'node', 'npm', 'yarn', 'pnpm',
-  'jest', 'vitest', 'cypress', 'playwright',
-  'tailwind', 'bootstrap', 'zod', 'trpc', 'graphql', 'rest',
-  'jwt', 'oauth', 'openai', 'anthropic', 'langchain',
-  'git', 'github', 'gitlab', 'eslint', 'prettier',
-  'zustand', 'redux', 'pinia', 'mobx', 'jotai', 'recoil',
-  'storybook', 'turborepo', 'nx',
-  'microservices', 'serverless', 'monolith', 'ssr', 'ssg', 'spa', 'pwa', 'mcp', 'rag'
-])
-
-// Aliases for common tech names
-const TECH_ALIASES: Record<string, string> = {
-  'ts': 'typescript', 'js': 'javascript', 'py': 'python',
-  'react.js': 'react', 'reactjs': 'react', 'vue.js': 'vue', 'vuejs': 'vue',
-  'next.js': 'nextjs', 'nuxt.js': 'nuxt', 'nest.js': 'nestjs',
-  'express.js': 'express', 'node.js': 'node', 'nodejs': 'node',
-  'mongo': 'mongodb', 'pg': 'postgresql', 'k8s': 'kubernetes',
-  'tailwindcss': 'tailwind', 'tailwind-css': 'tailwind',
-  'gql': 'graphql', 'golang': 'go',
-}
-
-// Common English words that should never be treated as project names
-const GENERIC_WORDS: Set<string> = new Set([
-  'small', 'large', 'big', 'new', 'old', 'good', 'bad', 'best', 'worst',
-  'simple', 'complex', 'easy', 'hard', 'fast', 'slow', 'quick', 'all',
-  'this', 'that', 'these', 'those', 'some', 'any', 'every', 'each',
-  'other', 'another', 'next', 'last', 'first', 'final', 'main', 'side',
-  'personal', 'general', 'specific', 'local', 'global', 'internal', 'external',
-  'current', 'future', 'past', 'recent', 'data', 'test', 'code', 'file',
-  'the', 'for', 'with', 'from', 'into', 'about', 'like', 'just', 'more',
-  'production', 'development', 'staging', 'projects', 'apps', 'tools',
-  'frontend', 'backend', 'fullstack', 'mobile', 'web', 'desktop', 'cli'
-])
-
-export interface BrainExtractedEntities {
-  project?: string
-  technologies: string[]
-  decision?: string
-  reasoning?: string
-  alternatives?: string
-  topic?: string
-  completedTask?: string
-  nextSteps?: string
-  original?: string
-  correction?: string
-  patternType?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
-}
-
-export class BrainEntityExtractor {
-  /** SLM Upgrade: Optional inference router for model-based entity extraction */
-  private inferenceRouter: any = null
-
-  /** SLM Upgrade: Set optional inference router for model-based NER */
-  setInferenceRouter(router: any): void {
-    this.inferenceRouter = router
-  }
-
-  /**
-   * Extract all entities from a natural language message
-   */
-  async extract(message: string, knownProject?: string): Promise<BrainExtractedEntities> {
-    const entities: BrainExtractedEntities = {
-      technologies: []
-    }
-
-    // Use provided project or try to detect from message
-    entities.project = knownProject || await this.extractProject(message)
-    entities.technologies = await this.extractTechnologies(message)
-    entities.topic = this.extractTopic(message)
-
-    // Extract decision components if present
-    const decisionParts = this.extractDecision(message)
-    if (decisionParts) {
-      entities.decision = decisionParts.decision
-      entities.reasoning = decisionParts.reasoning
-      entities.alternatives = decisionParts.alternatives
-    }
-
-    // Extract progress components
-    const progress = this.extractProgress(message)
-    if (progress) {
-      entities.completedTask = progress.completedTask
-      entities.nextSteps = progress.nextSteps
-    }
-
-    // Extract correction components
-    const correction = this.extractCorrection(message)
-    if (correction) {
-      entities.original = correction.original
-      entities.correction = correction.correction
-    }
-
-    // Extract pattern type
-    entities.patternType = this.extractPatternType(message)
-
-    return entities
-  }
-
-  /**
-   * Extract project name from message
-   */
-  private async extractProject(message: string): Promise<string | undefined> {
-    const lower = message.toLowerCase()
-
-    // Pattern: "in project X", "for project X", "on project X"
-    const projectPatterns = [
-      /(?:in|for|on)\s+(?:the\s+)?project\s+["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
-      /project\s*:\s*["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
-      /(?:in|for|on)\s+["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?\s+project/i,
-      // "working on X", "starting X", "resuming X"
-      /(?:working\s+on|starting|resuming|picking\s+up)\s+(?:the\s+)?["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
-    ]
-
-    for (const pattern of projectPatterns) {
-      const match = message.match(pattern)
-      if (match && match[1]) {
-        const candidate = match[1].toLowerCase()
-        // Filter out common false positives: tech names, generic words, adjectives
-        if (
-          !COMMON_TECH.has(candidate) &&
-          !GENERIC_WORDS.has(candidate) &&
-          candidate.length > 2 &&
-          candidate.length < 50
-        ) {
-          return candidate
-        }
-      }
-    }
-
-    // Try to match against known projects via vault service
-    if (isServicesInitialized()) {
-      try {
-        const vault = getVaultService()
-        const projects = await vault.listProjects()
-        for (const project of projects) {
-          if (lower.includes(project.toLowerCase())) {
-            return project
-          }
-        }
-      } catch {
-        // Vault service not available, skip project matching
-      }
-    }
-
-    return undefined
-  }
-
-  /**
-   * Extract technology mentions.
-   * SLM Upgrade: tries model-based NER first if InferenceRouter is available,
-   * merges with dictionary fallback for comprehensive coverage.
-   */
-  private async extractTechnologies(message: string): Promise<string[]> {
-    const found = new Set<string>()
-
-    // SLM: Try model-based entity extraction first
-    if (this.inferenceRouter) {
-      try {
-        const modelEntities = await this.inferenceRouter.extractEntities(message)
-        for (const entity of modelEntities) {
-          if (entity.type === 'technology') {
-            found.add(entity.normalizedName)
-          }
-        }
-      } catch {
-        // Model failed, fall through to dictionary
-      }
-    }
-
-    // Dictionary fallback (always runs — merges with model results)
-    const lower = message.toLowerCase()
-    const words = lower.split(/[\s,;:()[\]{}"'`|/\\]+/)
-
-    for (const word of words) {
-      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
-      if (cleaned.length < 2) continue
-
-      // Direct match
-      if (COMMON_TECH.has(cleaned)) {
-        found.add(cleaned)
-        continue
-      }
-
-      // Alias match
-      const alias = TECH_ALIASES[cleaned]
-      if (alias) {
-        found.add(alias)
-      }
-    }
-
-    // Check multi-word aliases
-    for (const [alias, normalized] of Object.entries(TECH_ALIASES)) {
-      if (alias.includes('.') || alias.includes('-')) {
-        if (lower.includes(alias)) {
-          found.add(normalized)
-        }
-      }
-    }
-
-    return Array.from(found)
-  }
-
-  /**
-   * Extract decision, reasoning, and alternatives
-   */
-  private extractDecision(message: string): { decision?: string; reasoning?: string; alternatives?: string } | null {
-    const lower = message.toLowerCase()
-
-    const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
-    if (!hasDecision) return null
-
-    // Find the decision phrase and extract text after it
-    let decision: string | undefined
-    for (const phrase of DECISION_PHRASES) {
-      const index = lower.indexOf(phrase)
-      if (index !== -1) {
-        const afterPhrase = message.substring(index + phrase.length).trim()
-        // Take until reasoning or sentence end
-        const endIndex = this.findClauseEnd(afterPhrase, REASONING_PHRASES)
-        decision = afterPhrase.substring(0, endIndex).trim()
-        if (decision.length > 5) break
-      }
-    }
-
-    // Extract reasoning
-    let reasoning: string | undefined
-    for (const phrase of REASONING_PHRASES) {
-      const index = lower.indexOf(phrase)
-      if (index !== -1) {
-        const afterPhrase = message.substring(index).trim()
-        const endIndex = Math.min(afterPhrase.length, 300)
-        const sentenceEnd = afterPhrase.search(/\n\n/)
-        reasoning = afterPhrase.substring(0, sentenceEnd !== -1 ? sentenceEnd : endIndex).trim()
-        if (reasoning.length > 10) break
-      }
-    }
-
-    // Extract alternatives
-    let alternatives: string | undefined
-    for (const phrase of ALTERNATIVE_PHRASES) {
-      const index = lower.indexOf(phrase)
-      if (index !== -1) {
-        const afterPhrase = message.substring(index + phrase.length).trim()
-        const endMatch = afterPhrase.match(/[.!?\n]/)
-        const endIndex = endMatch ? endMatch.index! + 1 : Math.min(afterPhrase.length, 150)
-        alternatives = afterPhrase.substring(0, endIndex).trim()
-        if (alternatives.length > 3) break
-      }
-    }
-
-    if (!decision && !reasoning) return null
-
-    return { decision, reasoning, alternatives }
-  }
-
-  /**
-   * Extract progress info: completed task and next steps
-   */
-  private extractProgress(message: string): { completedTask?: string; nextSteps?: string } | null {
-    const completedPatterns = [
-      /(?:finished|completed|done with|implemented|built|created|added|fixed|resolved|shipped)\s+(.+?)(?:\.|,\s*next|$)/i,
-    ]
-
-    const nextPatterns = [
-      /(?:next\s+(?:is|step|up|i'll|we'll|will\s+be)?|then\s+(?:i'll|we'll|will)|moving\s+(?:on\s+)?to)\s+(.+?)(?:\.|$)/i,
-    ]
-
-    let completedTask: string | undefined
-    let nextSteps: string | undefined
-
-    for (const pattern of completedPatterns) {
-      const match = message.match(pattern)
-      if (match && match[1] && match[1].length > 3) {
-        completedTask = match[1].trim()
-        break
-      }
-    }
-
-    for (const pattern of nextPatterns) {
-      const match = message.match(pattern)
-      if (match && match[1] && match[1].length > 3) {
-        nextSteps = match[1].trim()
-        break
-      }
-    }
-
-    if (!completedTask) return null
-    return { completedTask, nextSteps }
-  }
-
-  /**
-   * Extract correction: original mistake and what should have been done
-   */
-  private extractCorrection(message: string): { original?: string; correction?: string } | null {
-    const lower = message.toLowerCase()
-
-    const correctionIndicators = [
-      'the bug was', 'the issue was', 'the problem was', 'mistake was',
-      'should have', 'should not have', "shouldn't have",
-      'lesson learned', "don't use", 'avoid using', 'never use',
-      'the fix is', 'the fix was', 'fixed by', 'solved by'
-    ]
-
-    const hasCorrection = correctionIndicators.some(p => lower.includes(p))
-    if (!hasCorrection) return null
-
-    // Extract the original problem
-    let original: string | undefined
-    const problemPatterns = [
-      /(?:the\s+(?:bug|issue|problem|mistake)\s+was)\s+(.+?)(?:\.|,|;|$)/i,
-      /(?:should\s+(?:have|not\s+have)|shouldn't\s+have)\s+(.+?)(?:\.|,|;|$)/i
-    ]
-
-    for (const pattern of problemPatterns) {
-      const match = message.match(pattern)
-      if (match && match[1] && match[1].length > 3) {
-        original = match[1].trim()
-        break
-      }
-    }
-
-    // Extract the correction
-    let correction: string | undefined
-    const fixPatterns = [
-      /(?:the\s+fix\s+(?:is|was)|fixed\s+by|solved\s+by|instead\s+(?:should|use))\s+(.+?)(?:\.|,|;|$)/i,
-      /(?:don't\s+use|avoid\s+using|never\s+use)\s+(.+?)(?:\.|,|;|$)/i
-    ]
-
-    for (const pattern of fixPatterns) {
-      const match = message.match(pattern)
-      if (match && match[1] && match[1].length > 3) {
-        correction = match[1].trim()
-        break
-      }
-    }
-
-    if (!original && !correction) return null
-    return { original: original || message.slice(0, 200), correction }
-  }
-
-  /**
-   * Extract pattern type from message
-   */
-  private extractPatternType(message: string): BrainExtractedEntities['patternType'] {
-    const lower = message.toLowerCase()
-    if (lower.includes('anti-pattern') || lower.includes('antipattern')) return 'anti-pattern'
-    if (lower.includes('best practice') || lower.includes('best-practice')) return 'best-practice'
-    if (lower.includes('common issue') || lower.includes('common-issue') || lower.includes('common problem')) return 'common-issue'
-    if (lower.includes('pattern') || lower.includes('reusable solution') || lower.includes('reusable approach')) return 'solution'
-    return undefined
-  }
-
-  /**
-   * Extract topic from message (main subject without noise words)
-   */
-  private extractTopic(message: string): string | undefined {
-    // For short messages, the whole thing is the topic
-    if (message.length < 80) {
-      const cleaned = message.replace(/[?.!]+$/, '').trim()
-      if (cleaned.length > 3) return cleaned
-    }
-
-    // For longer messages, extract the first meaningful clause
-    const sentences = message.split(/[.!?\n]+/).filter(s => s.trim().length > 3)
-    const first = sentences[0]
-    if (first) {
-      return first.trim().slice(0, 200)
-    }
-
-    return undefined
-  }
-
-  /**
-   * Find where a clause ends (at a reasoning phrase or sentence boundary)
-   */
-  private findClauseEnd(text: string, stopPhrases: string[]): number {
-    const lower = text.toLowerCase()
-
-    const phraseStart = stopPhrases.reduce((min, phrase) => {
-      const idx = lower.indexOf(phrase)
-      return idx !== -1 ? Math.min(min, idx) : min
-    }, text.length)
-
-    const sentenceEnd = text.search(/[.!?\n]/)
-    const end = sentenceEnd !== -1 ? sentenceEnd : text.length
-
-    return Math.min(phraseStart, end, 200)
-  }
-}
+/**
+ * Brain Entity Extractor
+ * Phase 16: Extracts structured data from natural language messages
+ * for the unified brain() tool routing
+ */
+
+import { getVaultService, isServicesInitialized } from '@/server/services'
+
+// Reuse phrase lists from decision detector
+const DECISION_PHRASES = [
+  'i recommend',
+  'you should use',
+  'the best approach',
+  'i suggest',
+  'better to use',
+  'prefer using',
+  'go with',
+  'choose',
+  'instead of',
+  'the right choice',
+  'decided to',
+  "let's use",
+  'we will use',
+  'the solution is',
+  'implement using',
+  'going with',
+  'switching to',
+  'adopting',
+  'we chose',
+  'the plan is to'
+]
+
+const REASONING_PHRASES = [
+  'because',
+  'since',
+  'due to',
+  'as it',
+  'which provides',
+  'this allows',
+  'this ensures',
+  'given that',
+  'considering',
+  'the reason is',
+  'this way'
+]
+
+const ALTERNATIVE_PHRASES = [
+  'instead of',
+  'rather than',
+  'over',
+  ' vs ',
+  'compared to',
+  'unlike',
+  'as opposed to'
+]
+
+// Compact tech dictionary for entity extraction (most common technologies)
+// Full dictionary is in knowledge/entity-extractor.ts — we use a subset for speed
+const COMMON_TECH: Set<string> = new Set([
+  'typescript', 'javascript', 'python', 'rust', 'go', 'java', 'ruby', 'php', 'swift', 'kotlin',
+  'react', 'vue', 'angular', 'svelte', 'nextjs', 'nuxt', 'remix', 'astro', 'solid',
+  'express', 'fastify', 'hono', 'nestjs', 'django', 'flask', 'fastapi', 'rails', 'spring',
+  'mongodb', 'redis', 'postgresql', 'postgres', 'mysql', 'sqlite', 'dynamodb', 'firebase', 'supabase',
+  'prisma', 'drizzle', 'typeorm', 'sequelize', 'chromadb', 'pinecone',
+  'docker', 'kubernetes', 'aws', 'gcp', 'azure', 'vercel', 'netlify',
+  'webpack', 'vite', 'esbuild', 'bun', 'deno', 'node', 'npm', 'yarn', 'pnpm',
+  'jest', 'vitest', 'cypress', 'playwright',
+  'tailwind', 'bootstrap', 'zod', 'trpc', 'graphql', 'rest',
+  'jwt', 'oauth', 'openai', 'anthropic', 'langchain',
+  'git', 'github', 'gitlab', 'eslint', 'prettier',
+  'zustand', 'redux', 'pinia', 'mobx', 'jotai', 'recoil',
+  'storybook', 'turborepo', 'nx',
+  'microservices', 'serverless', 'monolith', 'ssr', 'ssg', 'spa', 'pwa', 'mcp', 'rag'
+])
+
+// Aliases for common tech names
+const TECH_ALIASES: Record<string, string> = {
+  'ts': 'typescript', 'js': 'javascript', 'py': 'python',
+  'react.js': 'react', 'reactjs': 'react', 'vue.js': 'vue', 'vuejs': 'vue',
+  'next.js': 'nextjs', 'nuxt.js': 'nuxt', 'nest.js': 'nestjs',
+  'express.js': 'express', 'node.js': 'node', 'nodejs': 'node',
+  'mongo': 'mongodb', 'pg': 'postgresql', 'k8s': 'kubernetes',
+  'tailwindcss': 'tailwind', 'tailwind-css': 'tailwind',
+  'gql': 'graphql', 'golang': 'go',
+}
+
+// Common English words that should never be treated as project names
+const GENERIC_WORDS: Set<string> = new Set([
+  'small', 'large', 'big', 'new', 'old', 'good', 'bad', 'best', 'worst',
+  'simple', 'complex', 'easy', 'hard', 'fast', 'slow', 'quick', 'all',
+  'this', 'that', 'these', 'those', 'some', 'any', 'every', 'each',
+  'other', 'another', 'next', 'last', 'first', 'final', 'main', 'side',
+  'personal', 'general', 'specific', 'local', 'global', 'internal', 'external',
+  'current', 'future', 'past', 'recent', 'data', 'test', 'code', 'file',
+  'the', 'for', 'with', 'from', 'into', 'about', 'like', 'just', 'more',
+  'production', 'development', 'staging', 'projects', 'apps', 'tools',
+  'frontend', 'backend', 'fullstack', 'mobile', 'web', 'desktop', 'cli'
+])
+
+export interface BrainExtractedEntities {
+  project?: string
+  technologies: string[]
+  decision?: string
+  reasoning?: string
+  alternatives?: string
+  topic?: string
+  completedTask?: string
+  nextSteps?: string
+  original?: string
+  correction?: string
+  patternType?: 'solution' | 'anti-pattern' | 'best-practice' | 'common-issue'
+}
+
+export class BrainEntityExtractor {
+  /** SLM Upgrade: Optional inference router for model-based entity extraction */
+  private inferenceRouter: import('@/intelligence/inference-router').InferenceRouter | null = null
+
+  /** SLM Upgrade: Set optional inference router for model-based NER */
+  setInferenceRouter(router: import('@/intelligence/inference-router').InferenceRouter): void {
+    this.inferenceRouter = router
+  }
+
+  /**
+   * Extract all entities from a natural language message
+   */
+  async extract(message: string, knownProject?: string): Promise<BrainExtractedEntities> {
+    const entities: BrainExtractedEntities = {
+      technologies: []
+    }
+
+    // Use provided project or try to detect from message
+    entities.project = knownProject || await this.extractProject(message)
+    entities.technologies = await this.extractTechnologies(message)
+    entities.topic = this.extractTopic(message)
+
+    // Extract decision components if present
+    const decisionParts = this.extractDecision(message)
+    if (decisionParts) {
+      entities.decision = decisionParts.decision
+      entities.reasoning = decisionParts.reasoning
+      entities.alternatives = decisionParts.alternatives
+    }
+
+    // Extract progress components
+    const progress = this.extractProgress(message)
+    if (progress) {
+      entities.completedTask = progress.completedTask
+      entities.nextSteps = progress.nextSteps
+    }
+
+    // Extract correction components
+    const correction = this.extractCorrection(message)
+    if (correction) {
+      entities.original = correction.original
+      entities.correction = correction.correction
+    }
+
+    // Extract pattern type
+    entities.patternType = this.extractPatternType(message)
+
+    return entities
+  }
+
+  /**
+   * Extract project name from message
+   */
+  private async extractProject(message: string): Promise<string | undefined> {
+    const lower = message.toLowerCase()
+
+    // Pattern: "in project X", "for project X", "on project X"
+    const projectPatterns = [
+      /(?:in|for|on)\s+(?:the\s+)?project\s+["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+      /project\s*:\s*["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+      /(?:in|for|on)\s+["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?\s+project/i,
+      // "working on X", "starting X", "resuming X"
+      /(?:working\s+on|starting|resuming|picking\s+up)\s+(?:the\s+)?["']?([a-z0-9][a-z0-9-]*[a-z0-9])["']?/i,
+    ]
+
+    for (const pattern of projectPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1]) {
+        const candidate = match[1].toLowerCase()
+        // Filter out common false positives: tech names, generic words, adjectives
+        if (
+          !COMMON_TECH.has(candidate) &&
+          !GENERIC_WORDS.has(candidate) &&
+          candidate.length > 2 &&
+          candidate.length < 50
+        ) {
+          return candidate
+        }
+      }
+    }
+
+    // Try to match against known projects via vault service
+    if (isServicesInitialized()) {
+      try {
+        const vault = getVaultService()
+        const projects = await vault.listProjects()
+        for (const project of projects) {
+          if (lower.includes(project.toLowerCase())) {
+            return project
+          }
+        }
+      } catch {
+        // Vault service not available, skip project matching
+      }
+    }
+
+    return undefined
+  }
+
+  /**
+   * Extract technology mentions.
+   * SLM Upgrade: tries model-based NER first if InferenceRouter is available,
+   * merges with dictionary fallback for comprehensive coverage.
+   */
+  private async extractTechnologies(message: string): Promise<string[]> {
+    const found = new Set<string>()
+
+    // SLM: Try model-based entity extraction first
+    if (this.inferenceRouter) {
+      try {
+        const modelEntities = await this.inferenceRouter.extractEntities(message)
+        for (const entity of modelEntities) {
+          if (entity.type === 'technology') {
+            found.add(entity.normalizedName)
+          }
+        }
+      } catch {
+        // Model failed, fall through to dictionary
+      }
+    }
+
+    // Dictionary fallback (always runs — merges with model results)
+    const lower = message.toLowerCase()
+    const words = lower.split(/[\s,;:()[\]{}"'`|/\\]+/)
+
+    for (const word of words) {
+      const cleaned = word.replace(/^[^a-z0-9]+|[^a-z0-9]+$/g, '')
+      if (cleaned.length < 2) continue
+
+      // Direct match
+      if (COMMON_TECH.has(cleaned)) {
+        found.add(cleaned)
+        continue
+      }
+
+      // Alias match
+      const alias = TECH_ALIASES[cleaned]
+      if (alias) {
+        found.add(alias)
+      }
+    }
+
+    // Check multi-word aliases
+    for (const [alias, normalized] of Object.entries(TECH_ALIASES)) {
+      if (alias.includes('.') || alias.includes('-')) {
+        if (lower.includes(alias)) {
+          found.add(normalized)
+        }
+      }
+    }
+
+    return Array.from(found)
+  }
+
+  /**
+   * Extract decision, reasoning, and alternatives
+   */
+  private extractDecision(message: string): { decision?: string; reasoning?: string; alternatives?: string } | null {
+    const lower = message.toLowerCase()
+
+    const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
+    if (!hasDecision) return null
+
+    // Find the decision phrase and extract text after it
+    let decision: string | undefined
+    for (const phrase of DECISION_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index + phrase.length).trim()
+        // Take until reasoning or sentence end
+        const endIndex = this.findClauseEnd(afterPhrase, REASONING_PHRASES)
+        decision = afterPhrase.substring(0, endIndex).trim()
+        if (decision.length > 5) break
+      }
+    }
+
+    // Extract reasoning
+    let reasoning: string | undefined
+    for (const phrase of REASONING_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index).trim()
+        const endIndex = Math.min(afterPhrase.length, 300)
+        const sentenceEnd = afterPhrase.search(/\n\n/)
+        reasoning = afterPhrase.substring(0, sentenceEnd !== -1 ? sentenceEnd : endIndex).trim()
+        if (reasoning.length > 10) break
+      }
+    }
+
+    // Extract alternatives
+    let alternatives: string | undefined
+    for (const phrase of ALTERNATIVE_PHRASES) {
+      const index = lower.indexOf(phrase)
+      if (index !== -1) {
+        const afterPhrase = message.substring(index + phrase.length).trim()
+        const endMatch = afterPhrase.match(/[.!?\n]/)
+        const endIndex = endMatch ? endMatch.index! + 1 : Math.min(afterPhrase.length, 150)
+        alternatives = afterPhrase.substring(0, endIndex).trim()
+        if (alternatives.length > 3) break
+      }
+    }
+
+    if (!decision && !reasoning) return null
+
+    return { decision, reasoning, alternatives }
+  }
+
+  /**
+   * Extract progress info: completed task and next steps
+   */
+  private extractProgress(message: string): { completedTask?: string; nextSteps?: string } | null {
+    const completedPatterns = [
+      /(?:finished|completed|done with|implemented|built|created|added|fixed|resolved|shipped)\s+(.+?)(?:\.|,\s*next|$)/i,
+    ]
+
+    const nextPatterns = [
+      /(?:next\s+(?:is|step|up|i'll|we'll|will\s+be)?|then\s+(?:i'll|we'll|will)|moving\s+(?:on\s+)?to)\s+(.+?)(?:\.|$)/i,
+    ]
+
+    let completedTask: string | undefined
+    let nextSteps: string | undefined
+
+    for (const pattern of completedPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        completedTask = match[1].trim()
+        break
+      }
+    }
+
+    for (const pattern of nextPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        nextSteps = match[1].trim()
+        break
+      }
+    }
+
+    if (!completedTask) return null
+    return { completedTask, nextSteps }
+  }
+
+  /**
+   * Extract correction: original mistake and what should have been done
+   */
+  private extractCorrection(message: string): { original?: string; correction?: string } | null {
+    const lower = message.toLowerCase()
+
+    const correctionIndicators = [
+      'the bug was', 'the issue was', 'the problem was', 'mistake was',
+      'should have', 'should not have', "shouldn't have",
+      'lesson learned', "don't use", 'avoid using', 'never use',
+      'the fix is', 'the fix was', 'fixed by', 'solved by'
+    ]
+
+    const hasCorrection = correctionIndicators.some(p => lower.includes(p))
+    if (!hasCorrection) return null
+
+    // Extract the original problem
+    let original: string | undefined
+    const problemPatterns = [
+      /(?:the\s+(?:bug|issue|problem|mistake)\s+was)\s+(.+?)(?:\.|,|;|$)/i,
+      /(?:should\s+(?:have|not\s+have)|shouldn't\s+have)\s+(.+?)(?:\.|,|;|$)/i
+    ]
+
+    for (const pattern of problemPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        original = match[1].trim()
+        break
+      }
+    }
+
+    // Extract the correction
+    let correction: string | undefined
+    const fixPatterns = [
+      /(?:the\s+fix\s+(?:is|was)|fixed\s+by|solved\s+by|instead\s+(?:should|use))\s+(.+?)(?:\.|,|;|$)/i,
+      /(?:don't\s+use|avoid\s+using|never\s+use)\s+(.+?)(?:\.|,|;|$)/i
+    ]
+
+    for (const pattern of fixPatterns) {
+      const match = message.match(pattern)
+      if (match && match[1] && match[1].length > 3) {
+        correction = match[1].trim()
+        break
+      }
+    }
+
+    if (!original && !correction) return null
+    return { original: original || message.slice(0, 200), correction }
+  }
+
+  /**
+   * Extract pattern type from message
+   */
+  private extractPatternType(message: string): BrainExtractedEntities['patternType'] {
+    const lower = message.toLowerCase()
+    if (lower.includes('anti-pattern') || lower.includes('antipattern')) return 'anti-pattern'
+    if (lower.includes('best practice') || lower.includes('best-practice')) return 'best-practice'
+    if (lower.includes('common issue') || lower.includes('common-issue') || lower.includes('common problem')) return 'common-issue'
+    if (lower.includes('pattern') || lower.includes('reusable solution') || lower.includes('reusable approach')) return 'solution'
+    return undefined
+  }
+
+  /**
+   * Extract topic from message (main subject without noise words)
+   */
+  private extractTopic(message: string): string | undefined {
+    // For short messages, the whole thing is the topic
+    if (message.length < 80) {
+      const cleaned = message.replace(/[?.!]+$/, '').trim()
+      if (cleaned.length > 3) return cleaned
+    }
+
+    // For longer messages, extract the first meaningful clause
+    const sentences = message.split(/[.!?\n]+/).filter(s => s.trim().length > 3)
+    const first = sentences[0]
+    if (first) {
+      return first.trim().slice(0, 200)
+    }
+
+    return undefined
+  }
+
+  /**
+   * Find where a clause ends (at a reasoning phrase or sentence boundary)
+   */
+  private findClauseEnd(text: string, stopPhrases: string[]): number {
+    const lower = text.toLowerCase()
+
+    const phraseStart = stopPhrases.reduce((min, phrase) => {
+      const idx = lower.indexOf(phrase)
+      return idx !== -1 ? Math.min(min, idx) : min
+    }, text.length)
+
+    const sentenceEnd = text.search(/[.!?\n]/)
+    const end = sentenceEnd !== -1 ? sentenceEnd : text.length
+
+    return Math.min(phraseStart, end, 200)
+  }
+}