@timmeck/brain 1.1.1 → 1.8.0

package/src/db/migrations/index.ts

@@ -6,6 +6,9 @@ import { up as codeSchema } from './003_code_schema.js';
 import { up as synapsesSchema } from './004_synapses_schema.js';
 import { up as ftsIndexes } from './005_fts_indexes.js';
 import { up as synapsesPhase3 } from './006_synapses_phase3.js';
+import { up as feedbackSchema } from './007_feedback.js';
+import { up as gitIntegration } from './008_git_integration.js';
+import { up as embeddings } from './009_embeddings.js';
 
 interface Migration {
   version: number;
@@ -20,6 +23,9 @@ const migrations: Migration[] = [
   { version: 4, name: '004_synapses_schema', up: synapsesSchema },
   { version: 5, name: '005_fts_indexes', up: ftsIndexes },
   { version: 6, name: '006_synapses_phase3', up: synapsesPhase3 },
+  { version: 7, name: '007_feedback', up: feedbackSchema },
+  { version: 8, name: '008_git_integration', up: gitIntegration },
+  { version: 9, name: '009_embeddings', up: embeddings },
 ];
 
 function ensureMigrationsTable(db: Database.Database): void {

package/src/db/repositories/code-module.repository.ts

@@ -26,6 +26,33 @@ export class CodeModuleRepository {
         WHERE code_modules_fts MATCH ?
         ORDER BY rank
       `),
+      upsertSimilarity: db.prepare(`
+        INSERT INTO module_similarities (module_a_id, module_b_id, similarity_score)
+        VALUES (@module_a_id, @module_b_id, @similarity_score)
+        ON CONFLICT(module_a_id, module_b_id)
+        DO UPDATE SET similarity_score = @similarity_score, computed_at = datetime('now')
+      `),
+      findSimilarModules: db.prepare(`
+        SELECT ms.*, cm.name, cm.file_path, cm.language, cm.reusability_score
+        FROM module_similarities ms
+        JOIN code_modules cm ON (
+          CASE WHEN ms.module_a_id = ? THEN ms.module_b_id ELSE ms.module_a_id END
+        ) = cm.id
+        WHERE ms.module_a_id = ? OR ms.module_b_id = ?
+        ORDER BY ms.similarity_score DESC
+        LIMIT ?
+      `),
+      findHighSimilarityPairs: db.prepare(`
+        SELECT ms.*,
+          a.name as a_name, a.file_path as a_path,
+          b.name as b_name, b.file_path as b_path
+        FROM module_similarities ms
+        JOIN code_modules a ON ms.module_a_id = a.id
+        JOIN code_modules b ON ms.module_b_id = b.id
+        WHERE ms.similarity_score >= ?
+        ORDER BY ms.similarity_score DESC
+        LIMIT ?
+      `),
     };
   }
 
@@ -86,4 +113,30 @@ export class CodeModuleRepository {
   countAll(): number {
     return (this.stmts.countAll.get() as { count: number }).count;
   }
+
+  upsertSimilarity(moduleAId: number, moduleBId: number, score: number): void {
+    // Always store with smaller id first for consistency
+    const [a, b] = moduleAId < moduleBId ? [moduleAId, moduleBId] : [moduleBId, moduleAId];
+    this.stmts.upsertSimilarity.run({
+      module_a_id: a,
+      module_b_id: b,
+      similarity_score: score,
+    });
+  }
+
+  findSimilarModules(moduleId: number, limit: number = 10): Array<{ module_id: number; similarity_score: number; name: string; file_path: string }> {
+    return this.stmts.findSimilarModules.all(moduleId, moduleId, moduleId, limit) as Array<{
+      module_id: number; similarity_score: number; name: string; file_path: string;
+    }>;
+  }
+
+  findHighSimilarityPairs(minScore: number = 0.75, limit: number = 50): Array<{
+    module_a_id: number; module_b_id: number; similarity_score: number;
+    a_name: string; a_path: string; b_name: string; b_path: string;
+  }> {
+    return this.stmts.findHighSimilarityPairs.all(minScore, limit) as Array<{
+      module_a_id: number; module_b_id: number; similarity_score: number;
+      a_name: string; a_path: string; b_name: string; b_path: string;
+    }>;
+  }
 }

package/src/db/repositories/error.repository.ts

@@ -14,6 +14,22 @@ export class ErrorRepository {
         INSERT INTO errors (project_id, terminal_id, fingerprint, type, message, raw_output, context, file_path, line_number, column_number)
         VALUES (@project_id, @terminal_id, @fingerprint, @type, @message, @raw_output, @context, @file_path, @line_number, @column_number)
       `),
+      createChain: this.db.prepare(`
+        INSERT OR IGNORE INTO error_chains (parent_error_id, child_error_id, relationship)
+        VALUES (@parent_error_id, @child_error_id, @relationship)
+      `),
+      findChainChildren: this.db.prepare(
+        'SELECT e.* FROM errors e JOIN error_chains ec ON e.id = ec.child_error_id WHERE ec.parent_error_id = ?'
+      ),
+      findChainParents: this.db.prepare(
+        'SELECT e.* FROM errors e JOIN error_chains ec ON e.id = ec.parent_error_id WHERE ec.child_error_id = ?'
+      ),
+      findRecentByProject: this.db.prepare(
+        'SELECT * FROM errors WHERE project_id = ? AND first_seen >= ? ORDER BY first_seen DESC LIMIT ?'
+      ),
+      findAllPaginated: this.db.prepare(
+        'SELECT * FROM errors ORDER BY last_seen DESC LIMIT ? OFFSET ?'
+      ),
       getById: this.db.prepare(`
         SELECT * FROM errors WHERE id = ?
       `),
@@ -146,4 +162,28 @@ export class ErrorRepository {
   incrementOccurrence(id: number): void {
     this.stmts.incrementOccurrence.run(id);
   }
+
+  createChain(parentErrorId: number, childErrorId: number, relationship: string = 'caused_by_fix'): void {
+    this.stmts.createChain.run({
+      parent_error_id: parentErrorId,
+      child_error_id: childErrorId,
+      relationship,
+    });
+  }
+
+  findChainChildren(errorId: number): ErrorRecord[] {
+    return this.stmts.findChainChildren.all(errorId) as ErrorRecord[];
+  }
+
+  findChainParents(errorId: number): ErrorRecord[] {
+    return this.stmts.findChainParents.all(errorId) as ErrorRecord[];
+  }
+
+  findRecentByProject(projectId: number, since: string, limit: number = 10): ErrorRecord[] {
+    return this.stmts.findRecentByProject.all(projectId, since, limit) as ErrorRecord[];
+  }
+
+  findAll(limit: number = 100, offset: number = 0): ErrorRecord[] {
+    return this.stmts.findAllPaginated.all(limit, offset) as ErrorRecord[];
+  }
 }

package/src/db/repositories/insight.repository.ts

@@ -75,4 +75,25 @@ export class InsightRepository {
     const result = this.stmts.expire.run();
     return result.changes;
   }
+
+  rate(id: number, rating: number, comment?: string): boolean {
+    const stmt = this.db.prepare(
+      `UPDATE insights SET rating = ?, rating_comment = ?, rated_at = datetime('now') WHERE id = ?`
+    );
+    const result = stmt.run(rating, comment ?? null, id);
+    return result.changes > 0;
+  }
+
+  findRated(minRating?: number): InsightRecord[] {
+    if (minRating !== undefined) {
+      const stmt = this.db.prepare(
+        'SELECT * FROM insights WHERE rating IS NOT NULL AND rating >= ? ORDER BY rating DESC'
+      );
+      return stmt.all(minRating) as InsightRecord[];
+    }
+    const stmt = this.db.prepare(
+      'SELECT * FROM insights WHERE rating IS NOT NULL ORDER BY rating DESC'
+    );
+    return stmt.all() as InsightRecord[];
+  }
 }

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

@@ -13,13 +13,16 @@ import { importCommand } from './cli/commands/import.js';
 import { dashboardCommand } from './cli/commands/dashboard.js';
 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.0.0');
+  .version('1.8.0');
 
 program.addCommand(startCommand());
 program.addCommand(stopCommand());
@@ -33,6 +36,9 @@ program.addCommand(importCommand());
 program.addCommand(dashboardCommand());
 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,17 @@ 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()],
 
       // Code Brain
       ['code.analyze',            (params) => s.code.analyzeAndRegister(p(params))],
@@ -84,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)],
@@ -93,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)],
 
@@ -103,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 });