claude-brain 0.9.3 → 0.13.0

package/src/phase12/index.ts

@@ -1,456 +1,5 @@
 /**
- * Phase 12 Manager
- * Advanced Memory & Intelligent Automation
- *
- * Orchestrates all Phase 12 features:
- * - Pattern Recognition
- * - Learning System
- * - Knowledge Extraction
- * - Auto-Context Loading
- * - Decision Detection
- * - Proactive Recall
+ * Phase 12 Manager — Re-export stub
+ * Moved to @/automation/phase12-manager in Phase 22.3
  */
-
-import type { Logger } from 'pino'
-import type { VaultManager } from '@/vault'
-import type { MemoryManager } from '@/memory'
-import type { ContextManager } from '@/context'
-import { PatternRecognizer, type Pattern } from '@/memory/patterns'
-import { LearningSystem, type LearningInsights } from '@/memory/learning'
-import { KnowledgeExtractor, type ExtractedKnowledge } from '@/memory/knowledge-extractor'
-import {
-  ProjectDetector,
-  AutoContextLoader,
-  DecisionDetector,
-  ProactiveRecallEngine,
-  type DetectedProject,
-  type DetectedDecision,
-  type RecallResult
-} from '@/automation'
-
-export interface Phase12Config {
-  /**
-   * Enable automatic context loading on startup
-   * @default true
-   */
-  autoLoadContext: boolean
-
-  /**
-   * Enable automatic decision detection and saving
-   * @default true
-   */
-  autoDetectDecisions: boolean
-
-  /**
-   * Enable proactive memory recall
-   * @default true
-   */
-  enableProactiveRecall: boolean
-
-  /**
-   * Minimum confidence for auto-saving decisions
-   * @default 0.7
-   */
-  decisionConfidenceThreshold: number
-
-  /**
-   * Enable pattern analysis on startup
-   * @default false
-   */
-  analyzePatternsonStartup: boolean
-
-  /**
-   * Enable knowledge extraction from messages
-   * @default true
-   */
-  enableKnowledgeExtraction: boolean
-}
-
-const DEFAULT_CONFIG: Phase12Config = {
-  autoLoadContext: true,
-  autoDetectDecisions: true,
-  enableProactiveRecall: true,
-  decisionConfidenceThreshold: 0.7,
-  analyzePatternsonStartup: false,
-  enableKnowledgeExtraction: true
-}
-
-export interface MessageProcessingResult {
-  recalledMemories?: RecallResult
-  detectedDecision?: DetectedDecision
-  extractedKnowledge?: ExtractedKnowledge[]
-  detectedProject?: DetectedProject
-  decisionSaved?: boolean
-  decisionId?: string
-}
-
-export interface Phase12Stats {
-  patterns: {
-    total: number
-    byType: Record<string, number>
-  }
-  learning: LearningInsights
-  automation: {
-    contextLoaded: boolean
-    currentProject: string | null
-    recallStats: {
-      totalRecalls: number
-      successfulRecalls: number
-      averageRelevance: number
-    }
-  }
-}
-
-export class Phase12Manager {
-  private logger: Logger
-  private config: Phase12Config
-  private initialized = false
-
-  // Advanced Memory
-  public readonly patterns: PatternRecognizer
-  public readonly learning: LearningSystem
-  public readonly knowledge: KnowledgeExtractor
-
-  // Intelligent Automation
-  public readonly projectDetector: ProjectDetector
-  public readonly autoContext: AutoContextLoader
-  public readonly decisionDetector: DecisionDetector
-  public readonly proactiveRecall: ProactiveRecallEngine
-
-  constructor(
-    logger: Logger,
-    vault: VaultManager,
-    memory: MemoryManager,
-    context: ContextManager,
-    config: Partial<Phase12Config> = {}
-  ) {
-    this.logger = logger.child({ component: 'phase12-manager' })
-    this.config = { ...DEFAULT_CONFIG, ...config }
-
-    // Initialize advanced memory features
-    this.patterns = new PatternRecognizer(logger, memory)
-    this.learning = new LearningSystem(logger, memory)
-    this.knowledge = new KnowledgeExtractor(logger, memory)
-
-    // Initialize intelligent automation
-    this.projectDetector = new ProjectDetector(logger, vault)
-    this.autoContext = new AutoContextLoader(
-      logger,
-      context,
-      this.projectDetector
-    )
-    this.decisionDetector = new DecisionDetector(logger, memory)
-    this.proactiveRecall = new ProactiveRecallEngine(logger, memory)
-
-    this.logger.info(
-      { config: this.config },
-      'Phase 12 Manager created'
-    )
-  }
-
-  /**
-   * Initialize all Phase 12 features
-   */
-  async initialize(): Promise<void> {
-    if (this.initialized) {
-      this.logger.warn('Phase 12 already initialized')
-      return
-    }
-
-    this.logger.info('Initializing Phase 12 features...')
-
-    try {
-      // Start auto-context loader
-      if (this.config.autoLoadContext) {
-        await this.autoContext.initialize()
-        this.logger.info('Auto-context loader initialized')
-      }
-
-      // Run initial pattern analysis if enabled
-      if (this.config.analyzePatternsonStartup) {
-        const patterns = await this.patterns.analyzePatterns()
-        this.logger.info(
-          { patternCount: patterns.length },
-          'Initial pattern analysis complete'
-        )
-      }
-
-      this.initialized = true
-      this.logger.info('Phase 12 initialization complete')
-    } catch (error) {
-      this.logger.error({ error }, 'Phase 12 initialization failed')
-      throw error
-    }
-  }
-
-  /**
-   * Check if Phase 12 is initialized
-   */
-  isInitialized(): boolean {
-    return this.initialized
-  }
-
-  /**
-   * Process incoming message with all Phase 12 features
-   */
-  async processMessage(
-    message: string,
-    project?: string
-  ): Promise<MessageProcessingResult> {
-    const results: MessageProcessingResult = {}
-
-    // Use detected project if not provided
-    const targetProject = project || this.autoContext.getCurrentProject() || undefined
-
-    // 1. Proactive recall
-    if (this.config.enableProactiveRecall) {
-      if (this.proactiveRecall.shouldRecall(message)) {
-        results.recalledMemories = await this.proactiveRecall.recall(
-          message,
-          targetProject
-        ) || undefined
-      }
-    }
-
-    // 2. Decision detection
-    if (this.config.autoDetectDecisions && targetProject) {
-      const decision = this.decisionDetector.detectDecision(message, targetProject)
-
-      if (decision && decision.confidence >= this.config.decisionConfidenceThreshold) {
-        results.detectedDecision = decision
-
-        // Auto-save if confidence is high enough
-        const decisionId = await this.decisionDetector.autoSaveDecision(
-          decision,
-          targetProject
-        )
-
-        if (decisionId) {
-          results.decisionSaved = true
-          results.decisionId = decisionId
-        }
-      }
-    }
-
-    // 3. Knowledge extraction
-    if (this.config.enableKnowledgeExtraction) {
-      const extracted = await this.knowledge.extractFromConversation(
-        message,
-        targetProject
-      )
-
-      if (extracted.knowledge.length > 0) {
-        results.extractedKnowledge = extracted.knowledge
-      }
-    }
-
-    // Log processing results
-    if (Object.keys(results).length > 0) {
-      this.logger.debug(
-        {
-          hasRecall: !!results.recalledMemories,
-          hasDecision: !!results.detectedDecision,
-          knowledgeCount: results.extractedKnowledge?.length || 0,
-          decisionSaved: results.decisionSaved
-        },
-        'Message processed with Phase 12 features'
-      )
-    }
-
-    return results
-  }
-
-  /**
-   * Process outgoing response for decisions
-   * Call this with Claude's responses to detect and save decisions
-   */
-  async processResponse(
-    response: string,
-    project?: string
-  ): Promise<MessageProcessingResult> {
-    const results: MessageProcessingResult = {}
-    const targetProject = project || this.autoContext.getCurrentProject() || undefined
-
-    // Decision detection on responses (Claude's decisions)
-    if (this.config.autoDetectDecisions && targetProject) {
-      const decision = this.decisionDetector.detectDecision(response, targetProject)
-
-      if (decision && decision.confidence >= this.config.decisionConfidenceThreshold) {
-        results.detectedDecision = decision
-
-        const decisionId = await this.decisionDetector.autoSaveDecision(
-          decision,
-          targetProject
-        )
-
-        if (decisionId) {
-          results.decisionSaved = true
-          results.decisionId = decisionId
-          this.logger.info(
-            { decisionId, project: targetProject },
-            'Decision auto-saved from response'
-          )
-        }
-      }
-    }
-
-    // Knowledge extraction from responses
-    if (this.config.enableKnowledgeExtraction) {
-      const extracted = await this.knowledge.extractFromConversation(
-        response,
-        targetProject
-      )
-
-      if (extracted.knowledge.length > 0) {
-        results.extractedKnowledge = extracted.knowledge
-      }
-    }
-
-    return results
-  }
-
-  /**
-   * Get proactively recalled context for a query
-   */
-  async getRecalledContext(query: string, project?: string): Promise<string | null> {
-    const result = await this.proactiveRecall.recall(
-      query,
-      project || this.autoContext.getCurrentProject() || undefined
-    )
-
-    return result?.formattedContext || null
-  }
-
-  /**
-   * Get relevant patterns for a query
-   */
-  async getRelevantPatterns(query: string): Promise<Pattern[]> {
-    return this.patterns.getRelevantPatterns(query)
-  }
-
-  /**
-   * Record a correction for learning
-   */
-  async recordCorrection(
-    original: string,
-    corrected: string,
-    reasoning: string,
-    project?: string
-  ): Promise<string> {
-    const targetProject = project || this.autoContext.getCurrentProject() || 'global'
-    return this.learning.recordCorrection(original, corrected, reasoning, targetProject)
-  }
-
-  /**
-   * Get comprehensive Phase 12 statistics
-   */
-  getStats(): Phase12Stats {
-    const allPatterns = this.patterns.getAllPatterns()
-    const patternsByType: Record<string, number> = {}
-
-    for (const pattern of allPatterns) {
-      patternsByType[pattern.type] = (patternsByType[pattern.type] || 0) + 1
-    }
-
-    const recallStats = this.proactiveRecall.getStats()
-
-    return {
-      patterns: {
-        total: allPatterns.length,
-        byType: patternsByType
-      },
-      learning: this.learning.getLearningInsights(),
-      automation: {
-        contextLoaded: this.autoContext.getCurrentContext() !== undefined,
-        currentProject: this.autoContext.getCurrentProject(),
-        recallStats: {
-          totalRecalls: recallStats.totalRecalls,
-          successfulRecalls: recallStats.successfulRecalls,
-          averageRelevance: recallStats.averageRelevance
-        }
-      }
-    }
-  }
-
-  /**
-   * Get formatted status report
-   */
-  getStatusReport(): string {
-    const stats = this.getStats()
-    const parts: string[] = []
-
-    parts.push('# Phase 12 Status Report\n')
-
-    // Current project
-    parts.push('## Current Context')
-    if (stats.automation.currentProject) {
-      parts.push(`- **Project:** ${stats.automation.currentProject}`)
-      parts.push(`- **Context Loaded:** Yes`)
-    } else {
-      parts.push('- **Project:** Not detected (use smart_context to load project context)')
-      parts.push('- **Context Loaded:** No')
-    }
-    parts.push('')
-
-    // Pattern analysis
-    parts.push('## Pattern Analysis')
-    parts.push(`- **Total Patterns:** ${stats.patterns.total}`)
-    if (stats.patterns.total === 0) {
-      parts.push('  *No patterns stored yet. Use `recognize_pattern` to document reusable solutions.*')
-    } else {
-      for (const [type, count] of Object.entries(stats.patterns.byType)) {
-        parts.push(`  - ${type}: ${count}`)
-      }
-    }
-    parts.push('')
-
-    // Learning system
-    parts.push('## Learning System')
-    parts.push(`- **Total Corrections:** ${stats.learning.correctionCount}`)
-    if (stats.learning.correctionCount === 0) {
-      parts.push('  *No corrections recorded yet. Use `record_correction` to document lessons learned.*')
-    }
-    parts.push(`- **Categories Improved:** ${stats.learning.categoriesImproved.join(', ') || 'None'}`)
-    if (stats.learning.preferences.length > 0) {
-      parts.push('- **Top Preferences:**')
-      for (const pref of stats.learning.preferences.slice(0, 3)) {
-        parts.push(`  - ${pref.category}: ${Math.round(pref.strength * 100)}% confidence`)
-      }
-    }
-    parts.push('')
-
-    // Proactive recall
-    parts.push('## Proactive Recall')
-    parts.push(`- **Total Recalls:** ${stats.automation.recallStats.totalRecalls}`)
-    parts.push(`- **Successful:** ${stats.automation.recallStats.successfulRecalls}`)
-    const successRate = stats.automation.recallStats.totalRecalls > 0
-      ? Math.round((stats.automation.recallStats.successfulRecalls / stats.automation.recallStats.totalRecalls) * 100)
-      : 0
-    parts.push(`- **Success Rate:** ${successRate}%`)
-    parts.push(`- **Average Relevance:** ${Math.round(stats.automation.recallStats.averageRelevance * 100)}%`)
-
-    if (stats.automation.recallStats.totalRecalls === 0) {
-      parts.push('\n*Proactive recall activates automatically when you ask questions or request recommendations.*')
-    }
-
-    return parts.join('\n')
-  }
-
-  /**
-   * Cleanup and reset Phase 12
-   */
-  cleanup(): void {
-    this.autoContext.clearAllContexts()
-    this.patterns.clearPatterns()
-    this.learning.clearLearning()
-    this.proactiveRecall.resetStats()
-    this.initialized = false
-    this.logger.info('Phase 12 cleaned up')
-  }
-}
-
-// Re-export types
-export type { Pattern } from '@/memory/patterns'
-export type { Correction, Preference, LearningInsights } from '@/memory/learning'
-export type { ExtractedKnowledge, ExtractionResult } from '@/memory/knowledge-extractor'
-export type { DetectedProject, DetectedDecision, RecallResult } from '@/automation'
+export * from '@/automation/phase12-manager'

package/src/routing/intent-classifier.ts

@@ -1,9 +1,14 @@
 /**
  * Brain Intent Classifier
- * Phase 16: Rule-based intent classification for the unified brain() tool
+ * Phase 16 + Phase 19: Rule-based intent classification for the unified brain() tool
  *
  * Priority-ordered — first confident match wins.
  * No LLM calls, pure pattern matching.
+ *
+ * Phase 19 changes:
+ * - B1: Question confidence raised (? → 0.95, question word → 0.90)
+ * - B2: session_start narrowed (must be at start + no progress indicators)
+ * - B3: Temporal signal detection added to secondary intents
  */
 
 export type Intent =
@@ -51,7 +56,13 @@ const STORE_PHRASES = [
   'we should always', 'we should never',
   'i want to remember', 'don\'t forget',
   'for future reference', 'for the record',
-  'important:', 'key decision:', 'takeaway:'
+  'important:', 'key decision:', 'takeaway:',
+  // Issue 3: Declarative patterns ("X should be Y")
+  'should be', 'must be', 'needs to be', 'has to be',
+  'is set to', 'will be set', 'is always', 'are always',
+  'is configured to', 'is configured as',
+  // Issue 6: "I learned that" is a store, not a mistake
+  'i learned that'
 ]
 
 const REASONING_PHRASES = [
@@ -68,7 +79,7 @@ const MISTAKE_PHRASES = [
   'the fix is', 'the fix was', 'fixed by', 'solved by',
   'was wrong', 'was broken', 'was incorrect',
   'gotcha:', 'pitfall:', 'watch out for', 'be careful with',
-  'i learned that', 'turns out that'
+  'turns out that'
 ]
 
 // Progress indicators
@@ -102,13 +113,20 @@ const EXPLORATION_PHRASES = [
   'decisions about', 'when did we', 'list episodes'
 ]
 
-// Session start indicators
+// Session start indicators — Phase 19: narrowed to require start-of-message
 const SESSION_START_PHRASES = [
   'starting work', 'beginning work', 'resuming',
   'picking up', 'getting started', 'opening',
   'starting on', 'working on', 'beginning on'
 ]
 
+// Progress indicators that disqualify session_start
+const PROGRESS_INDICATORS = [
+  'finished', 'completed', 'done', 'fixed', 'resolved',
+  'shipped', 'deployed', 'merged', 'released', 'just did',
+  'making progress', 'currently working'
+]
+
 // Question indicators
 const QUESTION_WORDS = [
   'what', 'how', 'when', 'why', 'where', 'which',
@@ -128,7 +146,11 @@ const LIST_PHRASES = [
   'what have i decided', 'all my decisions', 'all decisions',
   'everything about', 'what do i know', 'what do we know',
   'show me everything', 'list decisions', 'list memories',
-  'browse', 'dump all', 'show my'
+  'browse', 'dump all', 'show my',
+  // Issue 4: Additional list phrases
+  'list everything', "everything i've stored", "everything i know",
+  "what have i stored", "stored in my brain", "what's in my brain",
+  "what have i remembered", "what do i have stored"
 ]
 
 // Update/correct existing memory
@@ -148,6 +170,21 @@ const DELETE_PHRASES = [
   'remove the memory', 'clear that', 'drop that'
 ]
 
+// Phase 19 B3: Temporal signal phrases
+const TEMPORAL_PHRASES = [
+  'last week', 'last month', 'last year', 'yesterday', 'today',
+  'this week', 'this month', 'this year',
+  'since january', 'since february', 'since march', 'since april',
+  'since may', 'since june', 'since july', 'since august',
+  'since september', 'since october', 'since november', 'since december',
+  'in january', 'in february', 'in march', 'in april',
+  'in may', 'in june', 'in july', 'in august',
+  'in september', 'in october', 'in november', 'in december',
+  'ago', 'recently', 'before', 'after', 'during',
+  'last few days', 'past week', 'past month',
+  'earlier this', 'earlier today', 'over the past'
+]
+
 export class IntentClassifier {
   /**
    * Classify the intent of a message
@@ -156,6 +193,9 @@ export class IntentClassifier {
     const lower = message.toLowerCase().trim()
     const secondary: Intent[] = []
 
+    // Phase 19 B3: Detect temporal signals for secondary intent
+    const hasTemporal = this.hasTemporalSignal(lower)
+
     // Check in priority order — first confident match wins
 
     // 1. no_action: very short messages, greetings, acknowledgments
@@ -204,6 +244,7 @@ export class IntentClassifier {
     // 9. comparison: vs, which is better, etc.
     if (this.isComparison(lower)) {
       if (this.isQuestion(lower, message)) secondary.push('question')
+      if (hasTemporal) secondary.push('exploration')
       return { primary: 'comparison', confidence: 0.85, secondary }
     }
 
@@ -212,7 +253,7 @@ export class IntentClassifier {
       return { primary: 'pattern_found', confidence: 0.80, secondary }
     }
 
-    // 11. session_start: starting/resuming work
+    // 11. session_start: starting/resuming work (Phase 19: narrowed check)
     if (this.isSessionStart(lower)) {
       secondary.push('context_needed')
       return { primary: 'session_start', confidence: 0.90, secondary }
@@ -221,17 +262,24 @@ export class IntentClassifier {
     // 12. exploration: timeline, trends, graph, history
     if (this.isExploration(lower)) {
       if (this.isQuestion(lower, message)) secondary.push('question')
+      if (hasTemporal) secondary.push('exploration')
       return { primary: 'exploration', confidence: 0.75, secondary }
     }
 
     // 13. question: starts with question word or ends with ?
+    // Phase 19 B1: Higher confidence for questions
     if (this.isQuestion(lower, message)) {
       if (this.hasComparisonSignal(lower)) secondary.push('comparison')
       if (this.hasExplorationSignal(lower)) secondary.push('exploration')
-      return { primary: 'question', confidence: 0.80, secondary }
+      if (hasTemporal) secondary.push('exploration')
+
+      // Phase 19 B1: ? → 0.95, question word → 0.90
+      const confidence = message.trim().endsWith('?') ? 0.95 : 0.90
+      return { primary: 'question', confidence, secondary }
     }
 
     // 14. Default: context_needed
+    if (hasTemporal) secondary.push('exploration')
     return { primary: 'context_needed', confidence: 0.60, secondary }
   }
 
@@ -247,6 +295,8 @@ export class IntentClassifier {
     if (original?.trim().endsWith('?')) return false
     const firstWord = lower.split(/\s+/)[0] || ''
     if (QUESTION_WORDS.includes(firstWord)) return false
+    // Phase 19 B4: Additional question guards
+    if (this.startsWithQuestionPattern(lower)) return false
     return STORE_PHRASES.some(p => lower.includes(p))
   }
 
@@ -255,6 +305,8 @@ export class IntentClassifier {
     if (original?.trim().endsWith('?')) return false
     const firstWord = lower.split(/\s+/)[0] || ''
     if (QUESTION_WORDS.includes(firstWord)) return false
+    // Phase 19 B4: Additional question guards
+    if (this.startsWithQuestionPattern(lower)) return false
 
     const hasDecision = DECISION_PHRASES.some(p => lower.includes(p))
     if (!hasDecision) return false
@@ -289,8 +341,23 @@ export class IntentClassifier {
     return hasPattern && lower.length > 50
   }
 
+  /**
+   * Phase 19 B2: Narrowed session_start detection.
+   * Must start at beginning of message AND have no progress indicators.
+   * "working on X" in the middle of a sentence is not a session start.
+   */
   private isSessionStart(lower: string): boolean {
-    return SESSION_START_PHRASES.some(p => lower.includes(p))
+    // Must NOT have progress indicators (e.g. "finished working on X" is progress, not session start)
+    if (PROGRESS_INDICATORS.some(p => lower.includes(p))) return false
+
+    // Phase 19 B2: Session phrases must match near the start of the message
+    for (const phrase of SESSION_START_PHRASES) {
+      const idx = lower.indexOf(phrase)
+      if (idx !== -1 && idx <= 5) {
+        return true
+      }
+    }
+    return false
   }
 
   private isExploration(lower: string): boolean {
@@ -300,7 +367,10 @@ export class IntentClassifier {
   private isQuestion(lower: string, original: string): boolean {
     if (original.trim().endsWith('?')) return true
     const firstWord = lower.split(/\s+/)[0] || ''
-    return QUESTION_WORDS.includes(firstWord)
+    if (QUESTION_WORDS.includes(firstWord)) return true
+    // Phase 19 B4: "do I", "did we", "have we", "can we" patterns
+    if (this.startsWithQuestionPattern(lower)) return true
+    return false
   }
 
   private isUpdateMemory(lower: string): boolean {
@@ -327,4 +397,32 @@ export class IntentClassifier {
   private hasSessionSignal(lower: string): boolean {
     return SESSION_START_PHRASES.some(p => lower.includes(p))
   }
+
+  /**
+   * Phase 19 B3: Detect temporal signals in the message.
+   * Used to add 'temporal' context to secondary intents.
+   */
+  hasTemporalSignal(lower: string): boolean {
+    return TEMPORAL_PHRASES.some(p => lower.includes(p))
+  }
+
+  /**
+   * Phase 19 B4: Extended question guards.
+   * Catches "do I", "did we", "have we", "can we" etc. patterns
+   * that start with auxiliary verbs not in the QUESTION_WORDS list.
+   */
+  private startsWithQuestionPattern(lower: string): boolean {
+    const questionStarters = [
+      'do i ', 'do we ', 'do you ',
+      'did i ', 'did we ', 'did you ',
+      'have i ', 'have we ', 'have you ',
+      'has it ', 'has the ',
+      'can i ', 'can we ', 'can you ',
+      'will i ', 'will we ', 'will you ',
+      'am i ', 'was i ', 'were we ',
+      'shall we ', 'shall i ',
+      'tell me '
+    ]
+    return questionStarters.some(p => lower.startsWith(p))
+  }
 }