claude-brain 0.14.2 → 0.14.4

package/src/automation/decision-detector.ts

@@ -1,452 +1,452 @@
-/**
- * Decision Detector
- * Phase 12: Advanced Memory & Intelligent Automation
- *
- * Detects when Claude makes decisions and automatically saves them
- */
-
-import type { Logger } from 'pino'
-import type { MemoryManager } from '@/memory'
-
-export interface DetectedDecision {
-  context: string
-  decision: string
-  reasoning: string
-  confidence: number
-  alternatives?: string
-  tags?: string[]
-}
-
-export interface DetectionResult {
-  detected: boolean
-  decision?: DetectedDecision
-  saved: boolean
-  decisionId?: string
-}
-
-export class DecisionDetector {
-  private logger: Logger
-  private memory: MemoryManager
-
-  // Decision-indicating phrases
-  private readonly 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'
-  ]
-
-  // Reasoning indicators
-  private readonly REASONING_PHRASES = [
-    'because',
-    'since',
-    'due to',
-    'as it',
-    'which provides',
-    'this allows',
-    'this ensures',
-    'given that',
-    'considering',
-    'the reason is',
-    'this way'
-  ]
-
-  // Alternative indicators
-  private readonly ALTERNATIVE_PHRASES = [
-    'instead of',
-    'rather than',
-    'over',
-    ' vs ',
-    'compared to',
-    'unlike',
-    'as opposed to'
-  ]
-
-  constructor(logger: Logger, memory: MemoryManager) {
-    this.logger = logger.child({ component: 'decision-detector' })
-    this.memory = memory
-  }
-
-  /**
-   * Detect decision from text
-   */
-  detectDecision(text: string, project?: string): DetectedDecision | null {
-    const textLower = text.toLowerCase()
-
-    // Check for decision phrases
-    const hasDecisionPhrase = this.DECISION_PHRASES.some(phrase =>
-      textLower.includes(phrase)
-    )
-
-    if (!hasDecisionPhrase) {
-      return null
-    }
-
-    // Extract decision components
-    const context = this.extractContext(text)
-    const decision = this.extractDecision(text)
-    const reasoning = this.extractReasoning(text)
-    const alternatives = this.extractAlternatives(text)
-    const tags = this.extractTags(text)
-
-    // Calculate confidence
-    const confidence = this.calculateConfidence(text, {
-      hasContext: !!context && context.length > 10,
-      hasReasoning: !!reasoning && reasoning.length > 10,
-      hasAlternatives: !!alternatives
-    })
-
-    if (confidence < 0.5) {
-      this.logger.debug(
-        { confidence },
-        'Low confidence decision detection - ignoring'
-      )
-      return null
-    }
-
-    return {
-      context,
-      decision,
-      reasoning,
-      confidence,
-      alternatives,
-      tags
-    }
-  }
-
-  /**
-   * Extract context from text
-   */
-  private extractContext(text: string): string {
-    const sentences = text.split(/[.!?]+/).filter(s => s.trim())
-
-    // Find sentence with decision phrase
-    for (let i = 0; i < sentences.length; i++) {
-      const sentence = sentences[i].toLowerCase()
-
-      if (this.DECISION_PHRASES.some(p => sentence.includes(p))) {
-        // Context is likely in previous sentences
-        if (i > 0) {
-          // Take up to 2 previous sentences for context
-          const contextSentences = sentences.slice(Math.max(0, i - 2), i)
-          return contextSentences.map(s => s.trim()).join('. ')
-        }
-      }
-    }
-
-    // Fallback: use first sentence
-    return sentences[0]?.trim() || 'General decision'
-  }
-
-  /**
-   * Extract the actual decision
-   */
-  private extractDecision(text: string): string {
-    const textLower = text.toLowerCase()
-
-    for (const phrase of this.DECISION_PHRASES) {
-      const index = textLower.indexOf(phrase)
-
-      if (index !== -1) {
-        // Extract text after the phrase
-        const afterPhrase = text.substring(index + phrase.length).trim()
-
-        // Get until next sentence or reasoning
-        const endIndex = this.findDecisionEnd(afterPhrase)
-        const decision = afterPhrase.substring(0, endIndex).trim()
-
-        // Clean up the decision
-        if (decision.length > 5) {
-          return decision.charAt(0).toUpperCase() + decision.slice(1)
-        }
-      }
-    }
-
-    return 'Decision detected but could not extract details'
-  }
-
-  /**
-   * Find where decision ends
-   */
-  private findDecisionEnd(text: string): number {
-    const textLower = text.toLowerCase()
-
-    // Decision ends at reasoning or new sentence
-    const reasoningStart = this.REASONING_PHRASES.reduce((min, phrase) => {
-      const index = textLower.indexOf(phrase)
-      return index !== -1 ? Math.min(min, index) : min
-    }, text.length)
-
-    const sentenceEnd = text.search(/[.!?\n]/)
-    const end = sentenceEnd !== -1 ? sentenceEnd : text.length
-
-    return Math.min(reasoningStart, end, 200) // Cap at 200 chars
-  }
-
-  /**
-   * Extract reasoning
-   */
-  private extractReasoning(text: string): string {
-    const textLower = text.toLowerCase()
-
-    for (const phrase of this.REASONING_PHRASES) {
-      const index = textLower.indexOf(phrase)
-
-      if (index !== -1) {
-        // Extract text after reasoning phrase
-        const afterPhrase = text.substring(index).trim()
-
-        // Get reasoning - take multiple sentences if they continue the thought
-        // Look for double newline or paragraph break as end marker
-        let endIndex = afterPhrase.search(/\n\n/)
-
-        // If no paragraph break, take up to 3 sentences or 300 chars, whichever is shorter
-        if (endIndex === -1) {
-          const sentences = afterPhrase.split(/[.!?]/)
-          if (sentences.length > 3) {
-            // Take first 3 sentences
-            const firstThree = sentences.slice(0, 3).join('. ')
-            endIndex = Math.min(firstThree.length, 300)
-          } else {
-            // Take all text up to 300 chars
-            endIndex = Math.min(afterPhrase.length, 300)
-          }
-        }
-
-        const reasoning = afterPhrase.substring(0, endIndex).trim()
-
-        if (reasoning.length > 10) {
-          return reasoning
-        }
-      }
-    }
-
-    return ''
-  }
-
-  /**
-   * Extract alternatives
-   */
-  private extractAlternatives(text: string): string | undefined {
-    const textLower = text.toLowerCase()
-
-    // Look for patterns like "We considered X", "Alternatives include X, Y", etc.
-    const alternativeIntros = [
-      'we considered',
-      'we also looked at',
-      'we evaluated',
-      'alternatives considered',
-      'alternatives include',
-      'other options'
-    ]
-
-    for (const intro of alternativeIntros) {
-      const introIndex = textLower.indexOf(intro)
-      if (introIndex !== -1) {
-        const afterIntro = text.substring(introIndex + intro.length).trim()
-
-        // Extract until we hit a sentence ending that starts a new thought
-        // Look for: period followed by capital letter, or double newline
-        const endMatch = afterIntro.match(/\.\s+[A-Z]|\n\n/)
-        const endIndex = endMatch ? endMatch.index! + 1 : Math.min(afterIntro.length, 200)
-
-        const alternatives = afterIntro.substring(0, endIndex).trim()
-
-        if (alternatives.length > 10) {
-          return alternatives
-        }
-      }
-    }
-
-    // Fallback: look for comparison phrases
-    for (const phrase of this.ALTERNATIVE_PHRASES) {
-      const index = textLower.indexOf(phrase)
-
-      if (index !== -1) {
-        const afterPhrase = text.substring(index + phrase.length).trim()
-
-        // Don't stop at commas - take until sentence end or new thought
-        const endMatch = afterPhrase.match(/\.\s+[A-Z]|\n\n|[.!?]$/)
-        const endIndex = endMatch ? endMatch.index! + 1 : Math.min(afterPhrase.length, 150)
-
-        const alternative = afterPhrase.substring(0, endIndex).trim()
-
-        if (alternative.length > 3) {
-          return alternative
-        }
-      }
-    }
-
-    return undefined
-  }
-
-  /**
-   * Extract tags from decision
-   */
-  private extractTags(text: string): string[] {
-    const tags: string[] = ['auto-detected']
-    const textLower = text.toLowerCase()
-
-    // Technology tags
-    const techPatterns = [
-      { pattern: /typescript|ts\b/i, tag: 'typescript' },
-      { pattern: /javascript|js\b/i, tag: 'javascript' },
-      { pattern: /react/i, tag: 'react' },
-      { pattern: /node\.?js/i, tag: 'nodejs' },
-      { pattern: /python/i, tag: 'python' },
-      { pattern: /database|sql|postgres|mysql|mongodb/i, tag: 'database' },
-      { pattern: /api|rest|graphql/i, tag: 'api' },
-      { pattern: /authentication|auth|login/i, tag: 'authentication' },
-      { pattern: /security/i, tag: 'security' },
-      { pattern: /performance|optimization/i, tag: 'performance' },
-      { pattern: /testing|test|spec/i, tag: 'testing' },
-      { pattern: /architecture|design/i, tag: 'architecture' }
-    ]
-
-    for (const { pattern, tag } of techPatterns) {
-      if (pattern.test(textLower)) {
-        tags.push(tag)
-      }
-    }
-
-    return [...new Set(tags)]
-  }
-
-  /**
-   * Calculate confidence score
-   */
-  private calculateConfidence(
-    text: string,
-    features: {
-      hasContext: boolean
-      hasReasoning: boolean
-      hasAlternatives: boolean
-    }
-  ): number {
-    let confidence = 0.5 // Base confidence
-
-    if (features.hasContext) confidence += 0.15
-    if (features.hasReasoning) confidence += 0.25
-    if (features.hasAlternatives) confidence += 0.1
-
-    // Bonus for strong decision language
-    const strongPhrases = ['definitely', 'clearly', 'must', 'strongly recommend']
-    const hasStrong = strongPhrases.some(p => text.toLowerCase().includes(p))
-    if (hasStrong) confidence += 0.1
-
-    // Length bonus (longer = more detailed = more confident)
-    if (text.length > 200) confidence += 0.05
-    if (text.length > 500) confidence += 0.05
-
-    return Math.min(confidence, 1.0)
-  }
-
-  /**
-   * Process text and optionally auto-save decision
-   */
-  async processText(
-    text: string,
-    project: string,
-    autoSave: boolean = true
-  ): Promise<DetectionResult> {
-    const decision = this.detectDecision(text, project)
-
-    if (!decision) {
-      return { detected: false, saved: false }
-    }
-
-    if (!autoSave || decision.confidence < 0.7) {
-      return {
-        detected: true,
-        decision,
-        saved: false
-      }
-    }
-
-    // Auto-save the decision
-    const decisionId = await this.autoSaveDecision(decision, project)
-
-    return {
-      detected: true,
-      decision,
-      saved: !!decisionId,
-      decisionId: decisionId || undefined
-    }
-  }
-
-  /**
-   * Auto-save decision if confidence is high enough
-   */
-  async autoSaveDecision(
-    detected: DetectedDecision,
-    project: string
-  ): Promise<string | null> {
-    if (detected.confidence < 0.7) {
-      this.logger.debug(
-        { confidence: detected.confidence },
-        'Confidence too low for auto-save'
-      )
-      return null
-    }
-
-    try {
-      const decisionId = await this.memory.rememberDecision(
-        project,
-        detected.context,
-        detected.decision,
-        detected.reasoning,
-        {
-          alternatives: detected.alternatives,
-          tags: detected.tags
-        }
-      )
-
-      this.logger.info(
-        { project, confidence: detected.confidence, decisionId },
-        'Decision auto-saved'
-      )
-
-      return decisionId
-
-    } catch (error) {
-      this.logger.error({ error }, 'Failed to auto-save decision')
-      return null
-    }
-  }
-
-  /**
-   * Batch process multiple texts
-   */
-  async processBatch(
-    texts: Array<{ text: string; project: string }>,
-    autoSave: boolean = true
-  ): Promise<DetectionResult[]> {
-    const results: DetectionResult[] = []
-
-    for (const { text, project } of texts) {
-      const result = await this.processText(text, project, autoSave)
-      results.push(result)
-    }
-
-    return results
-  }
-
-  /**
-   * Check if text likely contains a decision
-   */
-  quickCheck(text: string): boolean {
-    const textLower = text.toLowerCase()
-    return this.DECISION_PHRASES.some(phrase => textLower.includes(phrase))
-  }
-}
+/**
+ * Decision Detector
+ * Phase 12: Advanced Memory & Intelligent Automation
+ *
+ * Detects when Claude makes decisions and automatically saves them
+ */
+
+import type { Logger } from 'pino'
+import type { MemoryManager } from '@/memory'
+
+export interface DetectedDecision {
+  context: string
+  decision: string
+  reasoning: string
+  confidence: number
+  alternatives?: string
+  tags?: string[]
+}
+
+export interface DetectionResult {
+  detected: boolean
+  decision?: DetectedDecision
+  saved: boolean
+  decisionId?: string
+}
+
+export class DecisionDetector {
+  private logger: Logger
+  private memory: MemoryManager
+
+  // Decision-indicating phrases
+  private readonly 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'
+  ]
+
+  // Reasoning indicators
+  private readonly REASONING_PHRASES = [
+    'because',
+    'since',
+    'due to',
+    'as it',
+    'which provides',
+    'this allows',
+    'this ensures',
+    'given that',
+    'considering',
+    'the reason is',
+    'this way'
+  ]
+
+  // Alternative indicators
+  private readonly ALTERNATIVE_PHRASES = [
+    'instead of',
+    'rather than',
+    'over',
+    ' vs ',
+    'compared to',
+    'unlike',
+    'as opposed to'
+  ]
+
+  constructor(logger: Logger, memory: MemoryManager) {
+    this.logger = logger.child({ component: 'decision-detector' })
+    this.memory = memory
+  }
+
+  /**
+   * Detect decision from text
+   */
+  detectDecision(text: string, project?: string): DetectedDecision | null {
+    const textLower = text.toLowerCase()
+
+    // Check for decision phrases
+    const hasDecisionPhrase = this.DECISION_PHRASES.some(phrase =>
+      textLower.includes(phrase)
+    )
+
+    if (!hasDecisionPhrase) {
+      return null
+    }
+
+    // Extract decision components
+    const context = this.extractContext(text)
+    const decision = this.extractDecision(text)
+    const reasoning = this.extractReasoning(text)
+    const alternatives = this.extractAlternatives(text)
+    const tags = this.extractTags(text)
+
+    // Calculate confidence
+    const confidence = this.calculateConfidence(text, {
+      hasContext: !!context && context.length > 10,
+      hasReasoning: !!reasoning && reasoning.length > 10,
+      hasAlternatives: !!alternatives
+    })
+
+    if (confidence < 0.5) {
+      this.logger.debug(
+        { confidence },
+        'Low confidence decision detection - ignoring'
+      )
+      return null
+    }
+
+    return {
+      context,
+      decision,
+      reasoning,
+      confidence,
+      alternatives,
+      tags
+    }
+  }
+
+  /**
+   * Extract context from text
+   */
+  private extractContext(text: string): string {
+    const sentences = text.split(/[.!?]+/).filter(s => s.trim())
+
+    // Find sentence with decision phrase
+    for (let i = 0; i < sentences.length; i++) {
+      const sentence = sentences[i].toLowerCase()
+
+      if (this.DECISION_PHRASES.some(p => sentence.includes(p))) {
+        // Context is likely in previous sentences
+        if (i > 0) {
+          // Take up to 2 previous sentences for context
+          const contextSentences = sentences.slice(Math.max(0, i - 2), i)
+          return contextSentences.map(s => s.trim()).join('. ')
+        }
+      }
+    }
+
+    // Fallback: use first sentence
+    return sentences[0]?.trim() || 'General decision'
+  }
+
+  /**
+   * Extract the actual decision
+   */
+  private extractDecision(text: string): string {
+    const textLower = text.toLowerCase()
+
+    for (const phrase of this.DECISION_PHRASES) {
+      const index = textLower.indexOf(phrase)
+
+      if (index !== -1) {
+        // Extract text after the phrase
+        const afterPhrase = text.substring(index + phrase.length).trim()
+
+        // Get until next sentence or reasoning
+        const endIndex = this.findDecisionEnd(afterPhrase)
+        const decision = afterPhrase.substring(0, endIndex).trim()
+
+        // Clean up the decision
+        if (decision.length > 5) {
+          return decision.charAt(0).toUpperCase() + decision.slice(1)
+        }
+      }
+    }
+
+    return 'Decision detected but could not extract details'
+  }
+
+  /**
+   * Find where decision ends
+   */
+  private findDecisionEnd(text: string): number {
+    const textLower = text.toLowerCase()
+
+    // Decision ends at reasoning or new sentence
+    const reasoningStart = this.REASONING_PHRASES.reduce((min, phrase) => {
+      const index = textLower.indexOf(phrase)
+      return index !== -1 ? Math.min(min, index) : min
+    }, text.length)
+
+    const sentenceEnd = text.search(/[.!?\n]/)
+    const end = sentenceEnd !== -1 ? sentenceEnd : text.length
+
+    return Math.min(reasoningStart, end, 200) // Cap at 200 chars
+  }
+
+  /**
+   * Extract reasoning
+   */
+  private extractReasoning(text: string): string {
+    const textLower = text.toLowerCase()
+
+    for (const phrase of this.REASONING_PHRASES) {
+      const index = textLower.indexOf(phrase)
+
+      if (index !== -1) {
+        // Extract text after reasoning phrase
+        const afterPhrase = text.substring(index).trim()
+
+        // Get reasoning - take multiple sentences if they continue the thought
+        // Look for double newline or paragraph break as end marker
+        let endIndex = afterPhrase.search(/\n\n/)
+
+        // If no paragraph break, take up to 3 sentences or 300 chars, whichever is shorter
+        if (endIndex === -1) {
+          const sentences = afterPhrase.split(/[.!?]/)
+          if (sentences.length > 3) {
+            // Take first 3 sentences
+            const firstThree = sentences.slice(0, 3).join('. ')
+            endIndex = Math.min(firstThree.length, 300)
+          } else {
+            // Take all text up to 300 chars
+            endIndex = Math.min(afterPhrase.length, 300)
+          }
+        }
+
+        const reasoning = afterPhrase.substring(0, endIndex).trim()
+
+        if (reasoning.length > 10) {
+          return reasoning
+        }
+      }
+    }
+
+    return ''
+  }
+
+  /**
+   * Extract alternatives
+   */
+  private extractAlternatives(text: string): string | undefined {
+    const textLower = text.toLowerCase()
+
+    // Look for patterns like "We considered X", "Alternatives include X, Y", etc.
+    const alternativeIntros = [
+      'we considered',
+      'we also looked at',
+      'we evaluated',
+      'alternatives considered',
+      'alternatives include',
+      'other options'
+    ]
+
+    for (const intro of alternativeIntros) {
+      const introIndex = textLower.indexOf(intro)
+      if (introIndex !== -1) {
+        const afterIntro = text.substring(introIndex + intro.length).trim()
+
+        // Extract until we hit a sentence ending that starts a new thought
+        // Look for: period followed by capital letter, or double newline
+        const endMatch = afterIntro.match(/\.\s+[A-Z]|\n\n/)
+        const endIndex = endMatch ? endMatch.index! + 1 : Math.min(afterIntro.length, 200)
+
+        const alternatives = afterIntro.substring(0, endIndex).trim()
+
+        if (alternatives.length > 10) {
+          return alternatives
+        }
+      }
+    }
+
+    // Fallback: look for comparison phrases
+    for (const phrase of this.ALTERNATIVE_PHRASES) {
+      const index = textLower.indexOf(phrase)
+
+      if (index !== -1) {
+        const afterPhrase = text.substring(index + phrase.length).trim()
+
+        // Don't stop at commas - take until sentence end or new thought
+        const endMatch = afterPhrase.match(/\.\s+[A-Z]|\n\n|[.!?]$/)
+        const endIndex = endMatch ? endMatch.index! + 1 : Math.min(afterPhrase.length, 150)
+
+        const alternative = afterPhrase.substring(0, endIndex).trim()
+
+        if (alternative.length > 3) {
+          return alternative
+        }
+      }
+    }
+
+    return undefined
+  }
+
+  /**
+   * Extract tags from decision
+   */
+  private extractTags(text: string): string[] {
+    const tags: string[] = ['auto-detected']
+    const textLower = text.toLowerCase()
+
+    // Technology tags
+    const techPatterns = [
+      { pattern: /typescript|ts\b/i, tag: 'typescript' },
+      { pattern: /javascript|js\b/i, tag: 'javascript' },
+      { pattern: /react/i, tag: 'react' },
+      { pattern: /node\.?js/i, tag: 'nodejs' },
+      { pattern: /python/i, tag: 'python' },
+      { pattern: /database|sql|postgres|mysql|mongodb/i, tag: 'database' },
+      { pattern: /api|rest|graphql/i, tag: 'api' },
+      { pattern: /authentication|auth|login/i, tag: 'authentication' },
+      { pattern: /security/i, tag: 'security' },
+      { pattern: /performance|optimization/i, tag: 'performance' },
+      { pattern: /testing|test|spec/i, tag: 'testing' },
+      { pattern: /architecture|design/i, tag: 'architecture' }
+    ]
+
+    for (const { pattern, tag } of techPatterns) {
+      if (pattern.test(textLower)) {
+        tags.push(tag)
+      }
+    }
+
+    return [...new Set(tags)]
+  }
+
+  /**
+   * Calculate confidence score
+   */
+  private calculateConfidence(
+    text: string,
+    features: {
+      hasContext: boolean
+      hasReasoning: boolean
+      hasAlternatives: boolean
+    }
+  ): number {
+    let confidence = 0.5 // Base confidence
+
+    if (features.hasContext) confidence += 0.15
+    if (features.hasReasoning) confidence += 0.25
+    if (features.hasAlternatives) confidence += 0.1
+
+    // Bonus for strong decision language
+    const strongPhrases = ['definitely', 'clearly', 'must', 'strongly recommend']
+    const hasStrong = strongPhrases.some(p => text.toLowerCase().includes(p))
+    if (hasStrong) confidence += 0.1
+
+    // Length bonus (longer = more detailed = more confident)
+    if (text.length > 200) confidence += 0.05
+    if (text.length > 500) confidence += 0.05
+
+    return Math.min(confidence, 1.0)
+  }
+
+  /**
+   * Process text and optionally auto-save decision
+   */
+  async processText(
+    text: string,
+    project: string,
+    autoSave: boolean = true
+  ): Promise<DetectionResult> {
+    const decision = this.detectDecision(text, project)
+
+    if (!decision) {
+      return { detected: false, saved: false }
+    }
+
+    if (!autoSave || decision.confidence < 0.7) {
+      return {
+        detected: true,
+        decision,
+        saved: false
+      }
+    }
+
+    // Auto-save the decision
+    const decisionId = await this.autoSaveDecision(decision, project)
+
+    return {
+      detected: true,
+      decision,
+      saved: !!decisionId,
+      decisionId: decisionId || undefined
+    }
+  }
+
+  /**
+   * Auto-save decision if confidence is high enough
+   */
+  async autoSaveDecision(
+    detected: DetectedDecision,
+    project: string
+  ): Promise<string | null> {
+    if (detected.confidence < 0.7) {
+      this.logger.debug(
+        { confidence: detected.confidence },
+        'Confidence too low for auto-save'
+      )
+      return null
+    }
+
+    try {
+      const decisionId = await this.memory.rememberDecision(
+        project,
+        detected.context,
+        detected.decision,
+        detected.reasoning,
+        {
+          alternatives: detected.alternatives,
+          tags: detected.tags
+        }
+      )
+
+      this.logger.info(
+        { project, confidence: detected.confidence, decisionId },
+        'Decision auto-saved'
+      )
+
+      return decisionId
+
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to auto-save decision')
+      return null
+    }
+  }
+
+  /**
+   * Batch process multiple texts
+   */
+  async processBatch(
+    texts: Array<{ text: string; project: string }>,
+    autoSave: boolean = true
+  ): Promise<DetectionResult[]> {
+    const results: DetectionResult[] = []
+
+    for (const { text, project } of texts) {
+      const result = await this.processText(text, project, autoSave)
+      results.push(result)
+    }
+
+    return results
+  }
+
+  /**
+   * Check if text likely contains a decision
+   */
+  quickCheck(text: string): boolean {
+    const textLower = text.toLowerCase()
+    return this.DECISION_PHRASES.some(phrase => textLower.includes(phrase))
+  }
+}