claude-brain 0.27.2 → 0.28.0

package/src/routing/intent-classifier.ts

@@ -240,85 +240,94 @@ export class IntentClassifier {
     // Phase 19 B3: Detect temporal signals for secondary intent
     const hasTemporal = this.hasTemporalSignal(lower)
 
+    // SLM Phase 1A: Log classification for training data collection
+    const startTime = Date.now()
+
     // Check in priority order — first confident match wins
 
+    // Helper to log + return in one step
+    const ret = (result: ClassificationResult): ClassificationResult => {
+      this._logTraining(message, result, startTime)
+      return result
+    }
+
     // 1. no_action: very short messages, greetings, acknowledgments
     if (this.isNoAction(lower)) {
-      return { primary: 'no_action', confidence: 0.95, secondary: [] }
+      return ret({ primary: 'no_action', confidence: 0.95, secondary: [] })
     }
 
     // 2. delete_memory: "forget that", "delete", "remove"
     if (this.isDeleteMemory(lower)) {
-      return { primary: 'delete_memory', confidence: 0.90, secondary }
+      return ret({ primary: 'delete_memory', confidence: 0.90, secondary })
     }
 
     // 3. update_memory: "actually", "correction:", "change that to"
     if (this.isUpdateMemory(lower)) {
-      return { primary: 'update_memory', confidence: 0.85, secondary }
+      return ret({ primary: 'update_memory', confidence: 0.85, secondary })
     }
 
     // 4. store_this: explicit "remember:", "save this:", "I prefer" (never for questions)
     if (this.isStoreThis(lower, message)) {
       if (this.hasDecisionSignal(lower)) secondary.push('decision_made')
-      return { primary: 'store_this', confidence: 0.90, secondary }
+      return ret({ primary: 'store_this', confidence: 0.90, secondary })
     }
 
     // 5. decision_made: decision phrases + reasoning (never for questions)
     if (this.isDecisionMade(lower, message)) {
       if (this.hasComparisonSignal(lower)) secondary.push('comparison')
-      return { primary: 'decision_made', confidence: 0.85, secondary }
+      return ret({ primary: 'decision_made', confidence: 0.85, secondary })
     }
 
     // 6. mistake_learned: correction/bug/lesson indicators
     if (this.isMistakeLearned(lower)) {
-      return { primary: 'mistake_learned', confidence: 0.85, secondary }
+      return ret({ primary: 'mistake_learned', confidence: 0.85, secondary })
     }
 
     // 7. list_all: "list all", "what decisions", "show all"
     if (this.isListAll(lower, message)) {
-      return { primary: 'list_all', confidence: 0.85, secondary }
+      return ret({ primary: 'list_all', confidence: 0.85, secondary })
     }
 
     // 8. progress_update: completed task indicators (NOT questions)
     if (this.isProgressUpdate(lower, message)) {
       if (this.hasSessionSignal(lower)) secondary.push('session_start')
-      return { primary: 'progress_update', confidence: 0.85, secondary }
+      return ret({ primary: 'progress_update', confidence: 0.85, secondary })
     }
 
     // 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 }
+      return ret({ primary: 'comparison', confidence: 0.85, secondary })
     }
 
     // 10. pattern_found: explicit pattern documentation
     if (this.isPatternFound(lower)) {
-      return { primary: 'pattern_found', confidence: 0.80, secondary }
+      return ret({ primary: 'pattern_found', confidence: 0.80, secondary })
     }
 
     // 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 }
+      return ret({ primary: 'session_start', confidence: 0.90, secondary })
     }
 
     // 12. detail_request: "details obs_abc123", "show me <id>" (before exploration to avoid misclassification)
     if (this.isDetailRequest(lower)) {
-      return { primary: 'detail_request', confidence: 0.90, secondary }
+      return ret({ primary: 'detail_request', confidence: 0.90, secondary })
     }
 
     // 12b. timeline: "timeline for project", "what did I do yesterday", "recent activity" (before exploration)
     if (this.isTimeline(lower)) {
       if (hasTemporal) secondary.push('exploration')
-      return { primary: 'timeline', confidence: 0.85, secondary }
+      return ret({ primary: 'timeline', confidence: 0.85, secondary })
     }
 
     // 12c. exploration: trends, graph, evolution, history (general exploration that isn't a specific timeline)
     if (this.isExploration(lower)) {
       if (this.isQuestion(lower, message)) secondary.push('question')
       if (hasTemporal) secondary.push('exploration')
-      return { primary: 'exploration', confidence: 0.75, secondary }
+      return ret({ primary: 'exploration', confidence: 0.75, secondary })
     }
 
     // 13. question: starts with question word or ends with ?
@@ -330,12 +339,32 @@ export class IntentClassifier {
 
       // Phase 19 B1: ? → 0.95, question word → 0.90
       const confidence = message.trim().endsWith('?') ? 0.95 : 0.90
-      return { primary: 'question', confidence, secondary }
+      return ret({ primary: 'question', confidence, secondary })
     }
 
     // 14. Default: context_needed
     if (hasTemporal) secondary.push('exploration')
-    return { primary: 'context_needed', confidence: 0.60, secondary }
+    const defaultResult = { primary: 'context_needed' as Intent, confidence: 0.60, secondary }
+    this._logTraining(message, defaultResult, startTime)
+    return defaultResult
+  }
+
+  /**
+   * SLM Phase 1A: Log classification result for training data collection.
+   * Fire-and-forget, never blocks the main path.
+   */
+  private _logTraining(message: string, result: ClassificationResult, startTime: number): void {
+    try {
+      const { logTrainingData } = require('@/training/data-store')
+      logTrainingData({
+        task: 'intent' as const,
+        input: message,
+        output: JSON.stringify({ label: result.primary, secondary: result.secondary }),
+        metadata: JSON.stringify({ confidence: result.confidence, elapsed_ms: Date.now() - startTime }),
+      })
+    } catch {
+      // Training data logging is non-critical
+    }
   }
 
   private isNoAction(lower: string): boolean {

package/src/routing/router.ts

@@ -12,6 +12,7 @@
 
 import type { Logger } from 'pino'
 import { IntentClassifier, type ClassificationResult } from './intent-classifier'
+import type { InferenceRouter } from '@/intelligence/inference-router'
 import { BrainEntityExtractor, type BrainExtractedEntities } from './entity-extractor'
 import { ResponseFilter, type BrainResponse, type TierResults, type FilterableResult, formatCompactResponse, formatDetailResponse, formatTimeline, groupByDay } from './response-filter'
 import { SearchEngine } from './search-engine'
@@ -62,6 +63,9 @@ export class BrainRouter {
   private searchEngine: SearchEngine
   private logger: Logger
 
+  /** SLM Upgrade: Optional inference router for model-based classification */
+  private inferenceRouter: InferenceRouter | null = null
+
   /** Phase 30: Optional LLM compressor for long observations */
   private compressor: ObservationCompressor | null = null
 
@@ -80,6 +84,12 @@ export class BrainRouter {
     this.logger = logger.child({ component: 'brain-router' })
   }
 
+  /** SLM Upgrade: Set the optional inference router for model-based classification */
+  setInferenceRouter(router: InferenceRouter): void {
+    this.inferenceRouter = router
+    this.entityExtractor.setInferenceRouter(router)
+  }
+
   /** Phase 30: Set the optional LLM compressor */
   setCompressor(compressor: ObservationCompressor): void {
     this.compressor = compressor
@@ -120,8 +130,10 @@ export class BrainRouter {
       }
     }
 
-    // Classify intent
-    const classification = this.classifier.classify(message)
+    // Classify intent (SLM: use inference router if available, falls back to regex)
+    const classification = this.inferenceRouter
+      ? await this.inferenceRouter.classifyIntent(message)
+      : this.classifier.classify(message)
     this.logger.debug({ intent: classification.primary, confidence: classification.confidence }, 'Intent classified')
 
     // Route to handler
@@ -2163,6 +2175,14 @@ let routerInstance: BrainRouter | null = null
 export function getBrainRouter(logger: Logger): BrainRouter {
   if (!routerInstance) {
     routerInstance = new BrainRouter(logger)
+    // SLM Upgrade: Wire inference router if available
+    try {
+      const { getInferenceRouter } = require('@/server/services')
+      const ir = getInferenceRouter()
+      if (ir) routerInstance.setInferenceRouter(ir)
+    } catch {
+      // Services not initialized yet — will use regex fallback
+    }
   }
   return routerInstance
 }

package/src/server/handlers/list-tools.ts

@@ -2,8 +2,8 @@
  * List Tools Handler
  * Handles the MCP tools/list request
  *
- * In unified tool mode (Phase 16), only the brain() tool is exposed.
- * In legacy mode, all 25 tools + brain are exposed.
+ * In unified tool mode (default), exposes brain + search_code.
+ * In legacy mode, all tools are exposed.
  */
 
 import { ToolRegistry } from '@/tools/registry'
@@ -19,10 +19,10 @@ export async function handleListTools() {
     try {
       const { config } = getServices()
       if (config.unifiedToolMode) {
-        const brainTool = ToolRegistry.getToolByName('brain')
-        return {
-          tools: brainTool ? [brainTool] : []
-        }
+        const tools = ['brain', 'search_code']
+          .map(name => ToolRegistry.getToolByName(name))
+          .filter(Boolean)
+        return { tools }
       }
     } catch {
       // Services not ready, fall through to default

package/src/server/http-api.ts

@@ -6,7 +6,7 @@
 import { Hono } from 'hono'
 import type { Logger } from 'pino'
 import type { Config } from '@/config'
-import { getMemoryService, getVaultService, isServicesInitialized } from '@/server/services'
+import { getMemoryService, getVaultService, getInferenceRouter, isServicesInitialized } from '@/server/services'
 import { ResourceProvider } from '@/server/providers/resources'
 import type { MemoryManager } from '@/memory'
 import type { CapturedKnowledge, HookStats } from '@/hooks/types'
@@ -16,6 +16,7 @@ import type { CodeIndexer } from '@/code-intelligence/indexer'
 import type { CodeQuery } from '@/code-intelligence/query'
 import type { MemoryCodeLinker } from '@/code-intelligence/linker'
 import { setupWebViewer, setWebViewerCodeQuery } from '@/server/web-viewer'
+import { getTrainingStats, getModelFeedbackStats, getDisagreements } from '@/training/data-store'
 
 export class HttpApiServer {
   private app: Hono
@@ -135,6 +136,12 @@ export class HttpApiServer {
 
     // Phase 23b: Expose brain://context/auto via HTTP for testability
     this.app.get('/api/context/auto', () => this.handleContextAuto())
+
+    // Phase 6A: SLM feedback & model status endpoints
+    this.app.get('/api/models/status', () => this.handleModelsStatus())
+    this.app.get('/api/models/feedback', (c) => this.handleModelsFeedback(c))
+    this.app.get('/api/models/disagreements', (c) => this.handleModelsDisagreements(c))
+    this.app.get('/api/training/stats', () => this.handleTrainingStats())
   }
 
   private async handleListProjects(): Promise<Response> {
@@ -1047,6 +1054,81 @@ export class HttpApiServer {
     }
   }
 
+  // ─── Phase 6A: SLM Model Feedback Endpoints ────────────
+
+  private handleModelsStatus(): Response {
+    try {
+      const inferenceRouter = getInferenceRouter()
+      if (!inferenceRouter) {
+        return Response.json({
+          success: true,
+          data: { enabled: false, message: 'SLM inference not initialized' },
+        })
+      }
+      return Response.json({ success: true, data: inferenceRouter.getStatus() })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get model status')
+      return Response.json(
+        { success: false, error: 'Failed to get model status' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private handleModelsFeedback(c: any): Response {
+    try {
+      const task = c.req.query('task')
+      const stats = getModelFeedbackStats()
+
+      if (task) {
+        const taskStats = stats[task]
+        if (!taskStats) {
+          return Response.json(
+            { success: false, error: `Unknown task: ${task}` },
+            { status: 400 }
+          )
+        }
+        return Response.json({ success: true, data: { [task]: taskStats } })
+      }
+
+      return Response.json({ success: true, data: stats })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get model feedback stats')
+      return Response.json(
+        { success: false, error: 'Failed to get model feedback stats' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private handleModelsDisagreements(c: any): Response {
+    try {
+      const task = c.req.query('task') || 'intent'
+      const limit = parseInt(c.req.query('limit') || '50', 10)
+      const disagreements = getDisagreements(task, limit)
+      return Response.json({ success: true, data: disagreements })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get model disagreements')
+      return Response.json(
+        { success: false, error: 'Failed to get model disagreements' },
+        { status: 500 }
+      )
+    }
+  }
+
+  private handleTrainingStats(): Response {
+    try {
+      const stats = getTrainingStats()
+      return Response.json({ success: true, data: stats })
+    } catch (error) {
+      this.logger.error({ error }, 'Failed to get training stats')
+      return Response.json(
+        { success: false, error: 'Failed to get training stats' },
+        { status: 500 }
+      )
+    }
+  }
+
   async start(): Promise<void> {
     const port = this.config.port || 3000
 

package/src/server/services.ts

@@ -26,6 +26,8 @@ import { SemanticCache } from '@/intelligence/optimization/semantic-cache'
 import { PrecomputeEngine } from '@/intelligence/optimization/precompute'
 import { MemoryArchiver } from '@/memory/consolidation/archiver'
 import { ImportanceScorer } from '@/memory/consolidation/scorer'
+import { ModelManager } from '@/intelligence/model-manager'
+import { InferenceRouter } from '@/intelligence/inference-router'
 
 export interface KnowledgeGraphServiceContainer {
   graph: InMemoryKnowledgeGraph
@@ -53,6 +55,8 @@ export interface Services {
   codeIndexer: CodeIndexer | null
   codeQuery: CodeQuery | null
   codeLinker: MemoryCodeLinker | null
+  modelManager: ModelManager | null
+  inferenceRouter: InferenceRouter | null
   logger: Logger
   config: Config
 }
@@ -371,6 +375,25 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       serviceLogger.warn({ error }, 'Failed to initialize code linker, continuing without it')
     }
 
+    // Initialize SLM Model Manager & Inference Router
+    let modelManager: ModelManager | null = null
+    let inferenceRouter: InferenceRouter | null = null
+    try {
+      const slmModelsDir = config.slm?.modelsDir?.replace(/^~/, require('os').homedir())
+      modelManager = new ModelManager(serviceLogger, slmModelsDir)
+      inferenceRouter = new InferenceRouter(serviceLogger, config, modelManager)
+      const slmEnabled = config.slm?.enabled ?? false
+      serviceLogger.info({ enabled: slmEnabled }, 'SLM inference router initialized')
+    } catch (error) {
+      serviceLogger.warn({ error }, 'Failed to initialize SLM inference, continuing with regex only')
+    }
+
+    // Wire SLM inference into PatternRecognizer (Phase 4C)
+    if (inferenceRouter && phase12) {
+      phase12.patterns.setInferenceRouter(inferenceRouter)
+      serviceLogger.info('SLM inference wired into PatternRecognizer')
+    }
+
     // Store services
     services = {
       memory,
@@ -388,6 +411,8 @@ export async function initializeServices(config: Config, logger: Logger): Promis
       codeIndexer,
       codeQuery,
       codeLinker,
+      modelManager,
+      inferenceRouter,
       logger,
       config
     }
@@ -526,6 +551,22 @@ export function getCodeLinker(): MemoryCodeLinker | null {
   return services?.codeLinker ?? null
 }
 
+/**
+ * Get Model Manager (SLM Upgrade)
+ * Returns null if SLM is not initialized
+ */
+export function getModelManager(): ModelManager | null {
+  return services?.modelManager ?? null
+}
+
+/**
+ * Get Inference Router (SLM Upgrade)
+ * Returns null if SLM is not initialized
+ */
+export function getInferenceRouter(): InferenceRouter | null {
+  return services?.inferenceRouter ?? null
+}
+
 /**
  * Check if services are initialized
  */
@@ -617,6 +658,12 @@ export async function shutdownServices(): Promise<void> {
     }
   }
 
+  // Unload SLM models
+  if (services.modelManager) {
+    services.modelManager.unloadAll()
+    serviceLogger.info('SLM models unloaded')
+  }
+
   // Cleanup Phase 12
   services.phase12.cleanup()