@timmeck/brain 1.2.0 → 1.8.0

package/src/embeddings/engine.ts

@@ -0,0 +1,217 @@
+import path from 'node:path';
+import type Database from 'better-sqlite3';
+import { getLogger } from '../utils/logger.js';
+
+export interface EmbeddingConfig {
+  enabled: boolean;
+  modelName: string;
+  cacheDir: string;
+  sweepIntervalMs: number;
+  batchSize: number;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type Pipeline = any;
+
+export class EmbeddingEngine {
+  private pipeline: Pipeline = null;
+  private ready = false;
+  private loading = false;
+  private logger = getLogger();
+  private sweepTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private config: EmbeddingConfig,
+    private db: Database.Database,
+  ) {}
+
+  async initialize(): Promise<void> {
+    if (!this.config.enabled || this.loading || this.ready) return;
+
+    this.loading = true;
+    try {
+      const { pipeline, env } = await import('@huggingface/transformers');
+      env.cacheDir = this.config.cacheDir;
+
+      this.pipeline = await pipeline(
+        'feature-extraction',
+        this.config.modelName,
+        { dtype: 'q8' },
+      );
+
+      this.ready = true;
+      this.logger.info(`Embedding model loaded: ${this.config.modelName}`);
+    } catch (err) {
+      this.logger.warn(`Failed to load embedding model (will retry): ${err}`);
+      this.ready = false;
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  /** Start background embedding sweep */
+  start(): void {
+    if (!this.config.enabled) return;
+
+    // Initialize model in background
+    this.initialize().then(() => {
+      if (this.ready) {
+        // Run initial sweep
+        this.sweep().catch(err => this.logger.error('Embedding sweep error:', err));
+      }
+    });
+
+    // Periodic sweep for new entries
+    this.sweepTimer = setInterval(() => {
+      if (this.ready) {
+        this.sweep().catch(err => this.logger.error('Embedding sweep error:', err));
+      }
+    }, this.config.sweepIntervalMs);
+  }
+
+  stop(): void {
+    if (this.sweepTimer) {
+      clearInterval(this.sweepTimer);
+      this.sweepTimer = null;
+    }
+  }
+
+  isReady(): boolean {
+    return this.ready;
+  }
+
+  /** Generate embedding for a single text */
+  async embed(text: string): Promise<Float32Array | null> {
+    if (!this.ready || !this.pipeline) return null;
+
+    try {
+      const output = await this.pipeline(text, { pooling: 'mean', normalize: true });
+      const data = output.tolist()[0] as number[];
+      return new Float32Array(data);
+    } catch (err) {
+      this.logger.error(`Embedding error: ${err}`);
+      return null;
+    }
+  }
+
+  /** Generate embeddings for a batch of texts */
+  async embedBatch(texts: string[]): Promise<(Float32Array | null)[]> {
+    if (!this.ready || !this.pipeline || texts.length === 0) return texts.map(() => null);
+
+    try {
+      const output = await this.pipeline(texts, { pooling: 'mean', normalize: true });
+      const list = output.tolist() as number[][];
+      return list.map(v => new Float32Array(v));
+    } catch (err) {
+      this.logger.error(`Batch embedding error: ${err}`);
+      return texts.map(() => null);
+    }
+  }
+
+  /** Compute and store embeddings for entries that don't have them yet */
+  async sweep(): Promise<{ errors: number; modules: number }> {
+    let errorsProcessed = 0;
+    let modulesProcessed = 0;
+
+    // Process errors without embeddings
+    const pendingErrors = this.db.prepare(
+      'SELECT id, type, message, context FROM errors WHERE embedding IS NULL ORDER BY id DESC LIMIT ?'
+    ).all(this.config.batchSize) as Array<{ id: number; type: string; message: string; context: string | null }>;
+
+    if (pendingErrors.length > 0) {
+      const texts = pendingErrors.map(e =>
+        [e.type, e.message, e.context].filter(Boolean).join(' ')
+      );
+      const embeddings = await this.embedBatch(texts);
+
+      const updateStmt = this.db.prepare('UPDATE errors SET embedding = ? WHERE id = ?');
+      for (let i = 0; i < pendingErrors.length; i++) {
+        const emb = embeddings[i];
+        if (emb) {
+          updateStmt.run(EmbeddingEngine.serialize(emb), pendingErrors[i]!.id);
+          errorsProcessed++;
+        }
+      }
+    }
+
+    // Process code modules without embeddings
+    const pendingModules = this.db.prepare(
+      'SELECT id, name, description, file_path FROM code_modules WHERE embedding IS NULL ORDER BY id DESC LIMIT ?'
+    ).all(this.config.batchSize) as Array<{ id: number; name: string; description: string | null; file_path: string }>;
+
+    if (pendingModules.length > 0) {
+      const texts = pendingModules.map(m =>
+        [m.name, m.description, m.file_path].filter(Boolean).join(' ')
+      );
+      const embeddings = await this.embedBatch(texts);
+
+      const updateStmt = this.db.prepare('UPDATE code_modules SET embedding = ? WHERE id = ?');
+      for (let i = 0; i < pendingModules.length; i++) {
+        const emb = embeddings[i];
+        if (emb) {
+          updateStmt.run(EmbeddingEngine.serialize(emb), pendingModules[i]!.id);
+          modulesProcessed++;
+        }
+      }
+    }
+
+    if (errorsProcessed > 0 || modulesProcessed > 0) {
+      this.logger.info(`Embedding sweep: ${errorsProcessed} errors, ${modulesProcessed} modules processed`);
+    }
+
+    return { errors: errorsProcessed, modules: modulesProcessed };
+  }
+
+  /** Load vector scores for error matching (sync - reads pre-computed embeddings from DB) */
+  computeErrorVectorScores(errorId: number, projectId: number): Map<number, number> {
+    const scores = new Map<number, number>();
+
+    const errorRow = this.db.prepare(
+      'SELECT embedding FROM errors WHERE id = ?'
+    ).get(errorId) as { embedding: Buffer | null } | undefined;
+
+    if (!errorRow?.embedding) return scores;
+
+    const incoming = EmbeddingEngine.deserialize(errorRow.embedding);
+
+    const candidates = this.db.prepare(
+      'SELECT id, embedding FROM errors WHERE project_id = ? AND id != ? AND embedding IS NOT NULL'
+    ).all(projectId, errorId) as Array<{ id: number; embedding: Buffer }>;
+
+    for (const c of candidates) {
+      const candidate = EmbeddingEngine.deserialize(c.embedding);
+      scores.set(c.id, EmbeddingEngine.similarity(incoming, candidate));
+    }
+
+    return scores;
+  }
+
+  /** Load vector scores for code module matching (sync) */
+  computeModuleVectorScores(query: string, language?: string): Map<number, number> {
+    const scores = new Map<number, number>();
+    // This needs async embedding — use cached if available
+    // For now, return empty (vector search for modules is done during sweep)
+    return scores;
+  }
+
+  /** Serialize Float32Array to Buffer for SQLite BLOB storage */
+  static serialize(embedding: Float32Array): Buffer {
+    return Buffer.from(embedding.buffer, embedding.byteOffset, embedding.byteLength);
+  }
+
+  /** Deserialize SQLite BLOB to Float32Array */
+  static deserialize(buffer: Buffer): Float32Array {
+    const copy = Buffer.from(buffer);
+    return new Float32Array(copy.buffer, copy.byteOffset, copy.length / 4);
+  }
+
+  /** Cosine similarity (embeddings are L2-normalized, so dot product = cosine) */
+  static similarity(a: Float32Array, b: Float32Array): number {
+    if (a.length !== b.length) return 0;
+    let dot = 0;
+    for (let i = 0; i < a.length; i++) {
+      dot += a[i]! * b[i]!;
+    }
+    return Math.max(0, Math.min(1, dot));
+  }
+}

package/src/hooks/post-tool-use.ts

@@ -65,6 +65,8 @@ async function main(): Promise<void> {
     const result: any = await client.request('error.report', {
       project: 'auto-detected',
       errorOutput: input.tool_output,
+      command: input.tool_input?.command,
+      workingDirectory: process.cwd(),
     });
 
     if (result.matches?.length > 0) {

package/src/hooks/post-write.ts

@@ -95,6 +95,18 @@ async function main(): Promise<void> {
       }
     }
 
+    // Proactive Prevention: check if written code matches error-causing patterns
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const prevention: any = await client.request('prevention.checkCode', {
+      source: input.tool_input.content ?? '',
+      filePath,
+    });
+    if (prevention?.warnings?.length > 0) {
+      for (const warning of prevention.warnings.slice(0, 3)) {
+        process.stderr.write(`Brain WARNING: ${warning.message}\n`);
+      }
+    }
+
     // Auto-register the written file into Brain
     const fileName = filePath.replace(/\\/g, '/').split('/').pop() ?? 'unknown';
     const projectName = detectProject(filePath);

package/src/index.ts

@@ -15,13 +15,14 @@ import { learnCommand } from './cli/commands/learn.js';
 import { configCommand } from './cli/commands/config.js';
 import { projectsCommand } from './cli/commands/projects.js';
 import { doctorCommand } from './cli/commands/doctor.js';
+import { explainCommand } from './cli/commands/explain.js';
 
 const program = new Command();
 
 program
   .name('brain')
   .description('Brain — Adaptive Error Memory & Code Intelligence System')
-  .version('1.2.0');
+  .version('1.8.0');
 
 program.addCommand(startCommand());
 program.addCommand(stopCommand());
@@ -37,6 +38,7 @@ program.addCommand(learnCommand());
 program.addCommand(configCommand());
 program.addCommand(projectsCommand());
 program.addCommand(doctorCommand());
+program.addCommand(explainCommand());
 
 // Hidden command: run MCP server (called by Claude Code)
 program

package/src/ipc/router.ts

@@ -10,6 +10,7 @@ import type { SynapseService } from '../services/synapse.service.js';
 import type { ResearchService } from '../services/research.service.js';
 import type { NotificationService } from '../services/notification.service.js';
 import type { AnalyticsService } from '../services/analytics.service.js';
+import type { GitService } from '../services/git.service.js';
 import type { LearningEngine, LearningCycleResult } from '../learning/learning-engine.js';
 
 export interface Services {
@@ -22,6 +23,7 @@ export interface Services {
   research: ResearchService;
   notification: NotificationService;
   analytics: AnalyticsService;
+  git: GitService;
   learning?: LearningEngine;
 }
 
@@ -67,12 +69,14 @@ export class IpcRouter {
       ['error.match',             (params) => s.error.matchSimilar(p(params).error_id ?? p(params).errorId)],
       ['error.resolve',           (params) => s.error.resolve(p(params).error_id ?? p(params).errorId, p(params).solution_id ?? p(params).solutionId)],
       ['error.get',               (params) => s.error.getById(p(params).id)],
+      ['error.chain',             (params) => s.error.getErrorChain(p(params).error_id ?? p(params).errorId ?? p(params).id)],
 
       // Solutions
       ['solution.report',         (params) => s.solution.report(p(params))],
       ['solution.query',          (params) => s.solution.findForError(p(params).error_id ?? p(params).errorId)],
       ['solution.rate',           (params) => s.solution.rateOutcome(p(params))],
       ['solution.attempt',        (params) => s.solution.rateOutcome({ ...p(params), success: false })],
+      ['solution.efficiency',     () => s.solution.analyzeEfficiency()],
 
       // Projects
       ['project.list',            () => s.code.listProjects()],
@@ -87,6 +91,7 @@ export class IpcRouter {
       // Prevention
       ['prevention.check',        (params) => s.prevention.checkRules(p(params).errorType, p(params).message, p(params).projectId)],
       ['prevention.antipatterns',  (params) => s.prevention.checkAntipatterns(p(params).errorType ?? '', p(params).message ?? p(params).error_output ?? '', p(params).projectId)],
+      ['prevention.checkCode',    (params) => s.prevention.checkCodeForPatterns(p(params).source, p(params).filePath)],
 
       // Synapses
       ['synapse.context',         (params) => s.synapse.getErrorContext(p(params).errorId ?? p(params).error_id ?? p(params).node_id)],
@@ -96,6 +101,7 @@ export class IpcRouter {
 
       // Research / Insights
       ['research.insights',       (params) => s.research.getInsights(p(params))],
+      ['insight.rate',            (params) => s.research.rateInsight(p(params).id, p(params).rating, p(params).comment)],
       ['research.suggest',        (params) => s.research.getInsights({ limit: 10, activeOnly: true, ...p(params) })],
       ['research.trends',         (params) => s.research.getTrends(p(params)?.projectId, p(params)?.windowDays)],
 
@@ -106,6 +112,16 @@ export class IpcRouter {
       // Analytics
       ['analytics.summary',       (params) => s.analytics.getSummary(p(params)?.projectId)],
       ['analytics.network',       (params) => s.analytics.getNetworkOverview(p(params)?.limit)],
+      ['analytics.health',        (params) => s.analytics.computeHealthScore(p(params)?.projectId)],
+      ['analytics.timeline',      (params) => s.analytics.getTimeSeries(p(params)?.projectId, p(params)?.days)],
+      ['analytics.explain',       (params) => s.analytics.explainError(p(params).errorId ?? p(params).error_id)],
+
+      // Git
+      ['git.context',             (params) => s.git.getGitContext(p(params)?.cwd)],
+      ['git.linkError',           (params) => s.git.linkErrorToCommit(p(params).errorId, p(params).projectId, p(params).commitHash, p(params).relationship)],
+      ['git.errorCommits',        (params) => s.git.findIntroducingCommit(p(params).errorId ?? p(params).error_id)],
+      ['git.commitErrors',        (params) => s.git.findErrorsByCommit(p(params).commitHash ?? p(params).commit_hash)],
+      ['git.diff',                (params) => s.git.captureDiff(p(params)?.cwd)],
 
       // Learning
       ['learning.run',            () => {

package/src/learning/confidence-scorer.ts

@@ -45,3 +45,36 @@ export function computeConfidence(
   if (total === 0) return 0;
   return timeDecayedConfidence(successCount, total, lastUsedAt, halfLifeDays);
 }
+
+export interface AdaptiveThresholds {
+  minOccurrences: number;
+  minSuccessRate: number;
+  minConfidence: number;
+  pruneThreshold: number;
+}
+
+/**
+ * Compute adaptive thresholds based on data volume.
+ * Users with lots of data need stricter thresholds; users with little data need looser ones.
+ */
+export function computeAdaptiveThresholds(
+  totalErrors: number,
+  totalSolutions: number,
+  baseConfig: { minOccurrences: number; minSuccessRate: number; minConfidence: number; pruneThreshold: number },
+): AdaptiveThresholds {
+  // Scale factor: 1.0 at 50 errors, increases with more data
+  const errorScale = Math.min(2.0, Math.max(0.5, totalErrors / 50));
+  const solutionScale = Math.min(2.0, Math.max(0.5, totalSolutions / 20));
+  const dataScale = (errorScale + solutionScale) / 2;
+
+  return {
+    // More data → require more occurrences before learning
+    minOccurrences: Math.max(2, Math.round(baseConfig.minOccurrences * dataScale)),
+    // More data → can afford higher success rate requirement
+    minSuccessRate: Math.min(0.95, baseConfig.minSuccessRate * (0.85 + dataScale * 0.15)),
+    // More data → higher confidence threshold
+    minConfidence: Math.min(0.90, baseConfig.minConfidence * (0.85 + dataScale * 0.15)),
+    // More data → stricter pruning
+    pruneThreshold: Math.max(0.10, baseConfig.pruneThreshold * (1.1 - dataScale * 0.1)),
+  };
+}

package/src/learning/learning-engine.ts

@@ -7,6 +7,7 @@ import type { SynapseManager } from '../synapses/synapse-manager.js';
 import { extractPatterns } from './pattern-extractor.js';
 import { generateRules, persistRules } from './rule-generator.js';
 import { shouldPruneRule } from './decay.js';
+import { computeAdaptiveThresholds, type AdaptiveThresholds } from './confidence-scorer.js';
 import { getLogger } from '../utils/logger.js';
 
 export interface LearningCycleResult {
@@ -56,12 +57,18 @@ export class LearningEngine {
       duration: 0,
     };
 
+    // Phase 0: Compute adaptive thresholds
+    const totalErrors = this.errorRepo.findUnresolved().length + this.errorRepo.countSince(new Date(0).toISOString());
+    const totalSolutions = this.solutionRepo.getAll().length;
+    const adaptive = computeAdaptiveThresholds(totalErrors, totalSolutions, this.config);
+    this.logger.debug(`Adaptive thresholds: minOcc=${adaptive.minOccurrences}, minSuccess=${adaptive.minSuccessRate.toFixed(2)}, minConf=${adaptive.minConfidence.toFixed(2)}`);
+
     // Phase 1: Collect recent errors
     const since = this.lastCycleAt ?? new Date(Date.now() - this.config.intervalMs).toISOString();
     const recentErrors = this.errorRepo.findUnresolved();
 
     // Phase 2: Extract patterns
-    const patterns = extractPatterns(recentErrors, 0.7);
+    const patterns = extractPatterns(recentErrors, adaptive.minSuccessRate);
     result.newPatterns = patterns.length;
 
     // Phase 3: Enrich patterns with solution data
@@ -87,18 +94,19 @@ export class LearningEngine {
       );
     }
 
-    // Phase 4: Generate rules from patterns
-    const rules = generateRules(patterns, this.config);
+    // Phase 4: Generate rules from patterns (using adaptive thresholds)
+    const adaptiveConfig = { ...this.config, ...adaptive };
+    const rules = generateRules(patterns, adaptiveConfig);
     result.updatedRules = persistRules(rules, this.ruleRepo);
 
-    // Phase 5: Prune weak rules
+    // Phase 5: Prune weak rules (using adaptive thresholds)
     const activeRules = this.ruleRepo.findActive();
     for (const rule of activeRules) {
       if (shouldPruneRule(
         rule.confidence,
         0, // rejection count not tracked yet
         rule.occurrences,
-        this.config.pruneThreshold,
+        adaptive.pruneThreshold,
         this.config.maxRejectionRate,
       )) {
         this.ruleRepo.update(rule.id, { active: 0 });

package/src/matching/error-matcher.ts

@@ -21,7 +21,8 @@ interface MatchSignal {
   compute: (a: ErrorRecord, b: ErrorRecord) => number;
 }
 
-const SIGNALS: MatchSignal[] = [
+// Base signals (used when vector search is NOT available)
+const SIGNALS_BASE: MatchSignal[] = [
   { name: 'fingerprint', weight: 0.30, compute: fingerprintMatch },
   { name: 'message_similarity', weight: 0.20, compute: messageSimilarity },
   { name: 'type_match', weight: 0.15, compute: typeMatch },
@@ -30,16 +31,41 @@ const SIGNALS: MatchSignal[] = [
   { name: 'context_similarity', weight: 0.10, compute: contextSimilarity },
 ];
 
+// Hybrid signals (used when vector search IS available — vector gets 20% weight)
+const SIGNALS_HYBRID: MatchSignal[] = [
+  { name: 'fingerprint', weight: 0.25, compute: fingerprintMatch },
+  { name: 'message_similarity', weight: 0.15, compute: messageSimilarity },
+  { name: 'type_match', weight: 0.12, compute: typeMatch },
+  { name: 'stack_similarity', weight: 0.12, compute: stackSimilarity },
+  { name: 'file_similarity', weight: 0.08, compute: fileSimilarity },
+  { name: 'context_similarity', weight: 0.08, compute: contextSimilarity },
+];
+
+const VECTOR_WEIGHT = 0.20;
 const MATCH_THRESHOLD = 0.70;
 const STRONG_MATCH_THRESHOLD = 0.90;
 
+/**
+ * Hybrid error matching: TF-IDF signals + optional vector similarity + synapse boost.
+ *
+ * @param incoming - The error to match
+ * @param candidates - Candidate errors to compare against
+ * @param vectorScores - Pre-computed vector similarity scores (errorId → score)
+ * @param synapseScores - Pre-computed synapse proximity scores (errorId → score)
+ */
 export function matchError(
   incoming: ErrorRecord,
   candidates: ErrorRecord[],
+  vectorScores?: Map<number, number>,
+  synapseScores?: Map<number, number>,
 ): MatchResult[] {
+  const useHybrid = vectorScores && vectorScores.size > 0;
+  const useSynapse = synapseScores && synapseScores.size > 0;
+  const signals = useHybrid ? SIGNALS_HYBRID : SIGNALS_BASE;
+
   return candidates
     .map(candidate => {
-      const signals = SIGNALS.map(signal => {
+      const signalResults = signals.map(signal => {
         const score = signal.compute(incoming, candidate);
         return {
           signal: signal.name,
@@ -48,12 +74,37 @@ export function matchError(
         };
       });
 
-      const totalScore = signals.reduce((sum, s) => sum + s.weighted, 0);
+      // Add vector similarity signal (if available)
+      if (useHybrid) {
+        const vectorScore = vectorScores.get(candidate.id) ?? 0;
+        signalResults.push({
+          signal: 'vector_similarity',
+          score: vectorScore,
+          weighted: vectorScore * VECTOR_WEIGHT,
+        });
+      }
+
+      let totalScore = signalResults.reduce((sum, s) => sum + s.weighted, 0);
+
+      // Synapse boost: if errors are already connected in the synapse network,
+      // give up to 5% bonus (doesn't create false positives, only reinforces)
+      if (useSynapse) {
+        const synapseScore = synapseScores.get(candidate.id) ?? 0;
+        if (synapseScore > 0) {
+          const bonus = Math.min(synapseScore * 0.05, 0.05);
+          totalScore = Math.min(1.0, totalScore + bonus);
+          signalResults.push({
+            signal: 'synapse_boost',
+            score: synapseScore,
+            weighted: bonus,
+          });
+        }
+      }
 
       return {
         errorId: candidate.id,
         score: totalScore,
-        signals,
+        signals: signalResults,
         isStrong: totalScore >= STRONG_MATCH_THRESHOLD,
       };
     })

package/src/mcp/http-server.ts

@@ -0,0 +1,137 @@
+import http from 'node:http';
+import { randomUUID } from 'node:crypto';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
+import { getLogger } from '../utils/logger.js';
+import type { IpcRouter } from '../ipc/router.js';
+import { registerToolsDirect } from './tools.js';
+
+export class McpHttpServer {
+  private server: http.Server | null = null;
+  private transports = new Map<string, SSEServerTransport>();
+  private logger = getLogger();
+
+  constructor(
+    private port: number,
+    private router: IpcRouter,
+  ) {}
+
+  start(): void {
+    this.server = http.createServer((req, res) => {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+
+      const url = new URL(req.url ?? '/', `http://localhost:${this.port}`);
+
+      if (url.pathname === '/sse' && req.method === 'GET') {
+        this.handleSSE(res);
+        return;
+      }
+
+      if (url.pathname === '/messages' && req.method === 'POST') {
+        this.handleMessage(req, res, url);
+        return;
+      }
+
+      if (url.pathname === '/' && req.method === 'GET') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({
+          name: 'brain',
+          version: '1.7.0',
+          protocol: 'MCP',
+          transport: 'sse',
+          endpoints: {
+            sse: '/sse',
+            messages: '/messages',
+          },
+          clients: this.transports.size,
+        }));
+        return;
+      }
+
+      res.writeHead(404, { 'Content-Type': 'text/plain' });
+      res.end('Not Found');
+    });
+
+    this.server.listen(this.port, () => {
+      this.logger.info(`MCP HTTP server (SSE) started on http://localhost:${this.port}`);
+    });
+  }
+
+  stop(): void {
+    this.transports.clear();
+    this.server?.close();
+    this.server = null;
+    this.logger.info('MCP HTTP server stopped');
+  }
+
+  getClientCount(): number {
+    return this.transports.size;
+  }
+
+  private async handleSSE(res: http.ServerResponse): Promise<void> {
+    try {
+      const transport = new SSEServerTransport('/messages', res);
+      const sessionId = transport.sessionId ?? randomUUID();
+      this.transports.set(sessionId, transport);
+
+      const server = new McpServer({
+        name: 'brain',
+        version: '1.7.0',
+      });
+
+      registerToolsDirect(server, this.router);
+
+      res.on('close', () => {
+        this.transports.delete(sessionId);
+        this.logger.debug(`MCP SSE client disconnected: ${sessionId}`);
+      });
+
+      await server.connect(transport);
+      this.logger.info(`MCP SSE client connected: ${sessionId}`);
+    } catch (err) {
+      this.logger.error('MCP SSE connection error:', err);
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Internal Server Error');
+      }
+    }
+  }
+
+  private async handleMessage(
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    url: URL,
+  ): Promise<void> {
+    try {
+      const sessionId = url.searchParams.get('sessionId');
+      if (!sessionId) {
+        res.writeHead(400, { 'Content-Type': 'text/plain' });
+        res.end('Missing sessionId parameter');
+        return;
+      }
+
+      const transport = this.transports.get(sessionId);
+      if (!transport) {
+        res.writeHead(404, { 'Content-Type': 'text/plain' });
+        res.end('Session not found. Connect to /sse first.');
+        return;
+      }
+
+      await transport.handlePostMessage(req, res);
+    } catch (err) {
+      this.logger.error('MCP message error:', err);
+      if (!res.headersSent) {
+        res.writeHead(500, { 'Content-Type': 'text/plain' });
+        res.end('Internal Server Error');
+      }
+    }
+  }
+}