neuronlayer 0.1.0

package/src/core/engine.ts

@@ -0,0 +1,1455 @@
+import { join, basename } from 'path';
+import { existsSync, mkdirSync, readFileSync, statSync } from 'fs';
+import { initializeDatabase, closeDatabase } from '../storage/database.js';
+import { Tier1Storage } from '../storage/tier1.js';
+import { Tier2Storage } from '../storage/tier2.js';
+import { Tier3Storage } from '../storage/tier3.js';
+import { Indexer } from '../indexing/indexer.js';
+import { ContextAssembler } from './context.js';
+import { DecisionTracker } from './decisions.js';
+import { DecisionExtractor } from './decision-extractor.js';
+import { LearningEngine } from './learning.js';
+import { FileSummarizer } from './summarizer.js';
+import { ProjectManager, type ProjectInfo } from './project-manager.js';
+import { ADRExporter, type ADRExportOptions } from './adr-exporter.js';
+import { FeatureContextManager, type ResurrectedContext, type ContextResurrectionOptions } from './feature-context.js';
+import { LivingDocumentationEngine } from './living-docs/index.js';
+import { ContextRotPrevention } from './context-rot/index.js';
+import { ConfidenceScorer } from './confidence/index.js';
+import { ChangeIntelligence } from './change-intelligence/index.js';
+import { ArchitectureEnforcement } from './architecture/index.js';
+import { TestAwareness } from './test-awareness/index.js';
+import { GhostMode, type GhostInsight, type ConflictWarning } from './ghost-mode.js';
+import { DejaVuDetector, type DejaVuMatch } from './deja-vu.js';
+import { CodeVerifier, type VerificationResult, type VerificationCheck, type ImportVerification, type SecurityScanResult, type DependencyCheckResult } from './code-verifier.js';
+import { detectLanguage, getPreview, countLines } from '../utils/files.js';
+import type { MemoryLayerConfig, AssembledContext, Decision, ProjectSummary, SearchResult, CodeSymbol, SymbolKind, ActiveFeatureContext, HotContext } from '../types/index.js';
+import type { ArchitectureDoc, ComponentDoc, DailyChangelog, ChangelogOptions, ValidationResult, ActivityResult, UndocumentedItem, ContextHealth, CompactionResult, CompactionOptions, CriticalContext, DriftResult, ConfidenceResult, ConfidenceLevel, ConfidenceSources, ConflictResult, ChangeQueryResult, ChangeQueryOptions, Diagnosis, PastBug, FixSuggestion, Change, Pattern, PatternCategory, PatternValidationResult, ExistingFunction, TestInfo, TestFramework, TestValidationResult, TestUpdate, TestCoverage } from '../types/documentation.js';
+import type Database from 'better-sqlite3';
+
+// Re-export types for external use
+export type { GhostInsight, ConflictWarning, DejaVuMatch, ResurrectedContext, VerificationResult, VerificationCheck, ImportVerification, SecurityScanResult, DependencyCheckResult };
+
+export class MemoryLayerEngine {
+  private config: MemoryLayerConfig;
+  private db: Database.Database;
+  private tier1: Tier1Storage;
+  private tier2: Tier2Storage;
+  private tier3: Tier3Storage;
+  private indexer: Indexer;
+  private contextAssembler: ContextAssembler;
+  private decisionTracker: DecisionTracker;
+  private learningEngine: LearningEngine;
+  private summarizer: FileSummarizer;
+  private projectManager: ProjectManager;
+  private adrExporter: ADRExporter;
+  private featureContextManager: FeatureContextManager;
+  private livingDocs: LivingDocumentationEngine;
+  private contextRotPrevention: ContextRotPrevention;
+  private confidenceScorer: ConfidenceScorer;
+  private changeIntelligence: ChangeIntelligence;
+  private architectureEnforcement: ArchitectureEnforcement;
+  private testAwareness: TestAwareness;
+  private ghostMode: GhostMode;
+  private dejaVu: DejaVuDetector;
+  private codeVerifier: CodeVerifier;
+  private backgroundInterval: NodeJS.Timeout | null = null;
+  private initialized = false;
+  private initializationStatus: 'pending' | 'indexing' | 'ready' | 'error' = 'pending';
+  private indexingProgress: { indexed: number; total: number } = { indexed: 0, total: 0 };
+
+  // Background intelligence settings
+  private readonly BACKGROUND_REFRESH_INTERVAL_MS = 5 * 60 * 1000; // 5 minutes
+
+  constructor(config: MemoryLayerConfig) {
+    this.config = config;
+
+    // Ensure data directory exists
+    if (!existsSync(config.dataDir)) {
+      mkdirSync(config.dataDir, { recursive: true });
+    }
+
+    // Initialize database
+    const dbPath = join(config.dataDir, 'memorylayer.db');
+    this.db = initializeDatabase(dbPath);
+
+    // Initialize storage tiers
+    this.tier1 = new Tier1Storage(config.dataDir);
+    this.tier2 = new Tier2Storage(this.db);
+    this.tier3 = new Tier3Storage(this.db);
+
+    // Initialize indexer
+    this.indexer = new Indexer(config, this.tier2);
+
+    // Initialize context assembler
+    this.contextAssembler = new ContextAssembler(
+      this.tier1,
+      this.tier2,
+      this.tier3,
+      this.indexer.getEmbeddingGenerator()
+    );
+
+    // Initialize decision tracker
+    this.decisionTracker = new DecisionTracker(
+      this.tier1,
+      this.tier2,
+      this.indexer.getEmbeddingGenerator()
+    );
+
+    // Phase 3: Initialize learning engine and summarizer
+    this.learningEngine = new LearningEngine(this.db);
+    this.summarizer = new FileSummarizer(this.db);
+
+    // Phase 4: Initialize project manager and ADR exporter
+    this.projectManager = new ProjectManager();
+    this.adrExporter = new ADRExporter(config.projectPath);
+
+    // Phase 5: Initialize feature context manager
+    this.featureContextManager = new FeatureContextManager(config.projectPath, config.dataDir);
+
+    // Wire up feature context manager to context assembler
+    this.contextAssembler.setFeatureContextManager(this.featureContextManager);
+
+    // Phase 6: Initialize living documentation engine
+    this.livingDocs = new LivingDocumentationEngine(
+      config.projectPath,
+      config.dataDir,
+      this.db,
+      this.tier2
+    );
+
+    // Phase 7: Initialize context rot prevention
+    this.contextRotPrevention = new ContextRotPrevention(this.db, config.maxTokens);
+
+    // Phase 8: Initialize confidence scorer
+    this.confidenceScorer = new ConfidenceScorer(
+      this.tier2,
+      this.indexer.getEmbeddingGenerator()
+    );
+
+    // Phase 9: Initialize change intelligence
+    this.changeIntelligence = new ChangeIntelligence(
+      config.projectPath,
+      this.db,
+      this.tier2,
+      this.indexer.getEmbeddingGenerator()
+    );
+
+    // Phase 10: Initialize architecture enforcement
+    this.architectureEnforcement = new ArchitectureEnforcement(
+      this.db,
+      this.tier2,
+      this.indexer.getEmbeddingGenerator()
+    );
+
+    // Phase 11: Initialize test awareness
+    this.testAwareness = new TestAwareness(
+      config.projectPath,
+      this.db,
+      this.tier2
+    );
+
+    // Phase 12: Initialize Ghost Mode (silent intelligence layer)
+    this.ghostMode = new GhostMode(
+      this.tier2,
+      this.indexer.getEmbeddingGenerator()
+    );
+
+    // Phase 12: Initialize Déjà Vu Detector
+    this.dejaVu = new DejaVuDetector(
+      this.db,
+      this.tier2,
+      this.indexer.getEmbeddingGenerator()
+    );
+
+    // Phase 13: Initialize Code Verifier (pre-commit quality gate)
+    this.codeVerifier = new CodeVerifier(config.projectPath);
+
+    // Register this project
+    const projectInfo = this.projectManager.registerProject(config.projectPath);
+    this.projectManager.setActiveProject(projectInfo.id);
+
+    this.setupIndexerEvents();
+  }
+
+  private setupIndexerEvents(): void {
+    this.indexer.on('indexingStarted', () => {
+      // Silent start - only show if files need indexing
+      this.indexingProgress = { indexed: 0, total: 0 };
+    });
+
+    this.indexer.on('progress', (progress) => {
+      // Track progress for status visibility
+      this.indexingProgress = { indexed: progress.indexed, total: progress.total || 0 };
+
+      // Only show progress when actually indexing files
+      if (progress.indexed === 1) {
+        console.error('Indexing new/changed files...');
+      }
+      if (progress.indexed % 10 === 0) {
+        console.error(`  ${progress.indexed} files indexed`);
+      }
+    });
+
+    this.indexer.on('indexingComplete', (stats: { total: number; indexed: number; skipped?: number }) => {
+      // Update final progress
+      this.indexingProgress = { indexed: stats.indexed, total: stats.total };
+
+      if (stats.indexed > 0) {
+        console.error(`Indexing complete: ${stats.indexed} files indexed`);
+      } else {
+        console.error(`Index up to date (${stats.total} files)`);
+      }
+      this.updateProjectSummary();
+      this.updateProjectStats();
+      // Extract decisions from git and comments
+      this.extractDecisions().catch(err => console.error('Decision extraction error:', err));
+    });
+
+    this.indexer.on('fileIndexed', (path) => {
+      // Track file in feature context
+      this.featureContextManager.onFileOpened(path);
+    });
+
+    this.indexer.on('error', (error) => {
+      console.error('Indexer error:', error);
+    });
+  }
+
+  async initialize(): Promise<void> {
+    if (this.initialized) return;
+
+    console.error(`Initializing MemoryLayer for: ${this.config.projectPath}`);
+
+    try {
+      // Perform initial indexing
+      this.initializationStatus = 'indexing';
+      await this.indexer.performInitialIndex();
+
+      // Start watching for changes
+      this.indexer.startWatching();
+
+      // Sync change intelligence from git
+      const synced = this.changeIntelligence.initialize();
+      if (synced > 0) {
+        console.error(`Synced ${synced} changes from git history`);
+      }
+
+      // Initialize architecture enforcement (learn patterns from codebase)
+      const archResult = this.architectureEnforcement.initialize();
+      if (archResult.patternsLearned > 0 || archResult.examplesAdded > 0) {
+        console.error(`Architecture enforcement: ${archResult.patternsLearned} patterns learned, ${archResult.examplesAdded} examples added`);
+      }
+
+      // Initialize test awareness (index tests)
+      const testResult = this.testAwareness.initialize();
+      if (testResult.testsIndexed > 0) {
+        console.error(`Test awareness: ${testResult.testsIndexed} tests indexed (${testResult.framework})`);
+      }
+
+      // Start background intelligence loop
+      this.startBackgroundIntelligence();
+
+      this.initialized = true;
+      this.initializationStatus = 'ready';
+      console.error('MemoryLayer initialized');
+    } catch (error) {
+      this.initializationStatus = 'error';
+      throw error;
+    }
+  }
+
+  /**
+   * Get the current engine status for visibility
+   */
+  getEngineStatus(): { status: string; ready: boolean; indexing: { indexed: number; total: number } } {
+    return {
+      status: this.initializationStatus,
+      ready: this.initialized,
+      indexing: this.indexingProgress
+    };
+  }
+
+  /**
+   * Background Intelligence Loop - continuously learn and update without user intervention
+   */
+  private startBackgroundIntelligence(): void {
+    // Clear any existing interval
+    if (this.backgroundInterval) {
+      clearInterval(this.backgroundInterval);
+    }
+
+    // Refresh git changes every 5 minutes
+    this.backgroundInterval = setInterval(() => {
+      try {
+        // Sync recent git changes
+        const synced = this.changeIntelligence.syncFromGit(20);
+        if (synced > 0) {
+          console.error(`[Background] Synced ${synced} recent changes from git`);
+        }
+
+        // Update importance scores for recently accessed files
+        this.learningEngine.updateImportanceScores();
+      } catch (error) {
+        // Silent fail for background tasks
+        console.error('[Background] Error in intelligence loop:', error);
+      }
+    }, this.BACKGROUND_REFRESH_INTERVAL_MS);
+  }
+
+  /**
+   * Record AI feedback - learn from what suggestions were actually used
+   */
+  recordAIFeedback(suggestion: string, wasUsed: boolean, correction?: string): void {
+    this.learningEngine.trackEvent({
+      eventType: wasUsed ? 'context_used' : 'context_ignored',
+      query: suggestion,
+    });
+
+    // If there was a correction, record it for learning
+    if (correction) {
+      this.dejaVu.recordQuery(correction, [], true);
+    }
+  }
+
+  async getContext(query: string, currentFile?: string, maxTokens?: number): Promise<AssembledContext> {
+    // Track the query
+    this.learningEngine.trackEvent({ eventType: 'query', query });
+
+    // Get expanded queries for better retrieval
+    const expandedQueries = this.learningEngine.expandQuery(query);
+
+    const result = await this.contextAssembler.assemble(query, {
+      currentFile,
+      maxTokens: maxTokens || this.config.maxTokens
+    });
+
+    // Track which files were included in context
+    for (const source of result.sources) {
+      this.learningEngine.trackEvent({ eventType: 'context_used', filePath: source, query });
+    }
+
+    // Track query pattern for future predictions
+    this.learningEngine.trackQuery(query, result.sources);
+
+    // Track in feature context
+    this.featureContextManager.onQuery(query, result.sources);
+
+    return result;
+  }
+
+  async searchCodebase(query: string, limit: number = 10): Promise<SearchResult[]> {
+    const embedding = await this.indexer.getEmbeddingGenerator().embed(query);
+    let results = this.tier2.search(embedding, limit * 2); // Get more for re-ranking
+
+    // Apply personalized ranking
+    results = this.learningEngine.applyPersonalizedRanking(results);
+
+    return results.slice(0, limit);
+  }
+
+  async recordDecision(
+    title: string,
+    description: string,
+    files?: string[],
+    tags?: string[]
+  ): Promise<Decision> {
+    return this.decisionTracker.recordDecision(title, description, files || [], tags || []);
+  }
+
+  getRecentDecisions(limit: number = 10): Decision[] {
+    return this.decisionTracker.getRecentDecisions(limit);
+  }
+
+  /**
+   * Search decisions in current project by query
+   */
+  async searchDecisions(query: string, limit: number = 5): Promise<Decision[]> {
+    const embedding = await this.indexer.getEmbeddingGenerator().embed(query);
+    return this.tier2.searchDecisions(embedding, limit);
+  }
+
+  async getFileContext(filePath: string): Promise<{ content: string; language: string; lines: number } | null> {
+    const absolutePath = join(this.config.projectPath, filePath);
+
+    if (!existsSync(absolutePath)) {
+      return null;
+    }
+
+    try {
+      // Check hot cache first
+      let content = this.learningEngine.getFromHotCache(filePath);
+
+      if (!content) {
+        content = readFileSync(absolutePath, 'utf-8');
+        // Add to hot cache for faster future access
+        this.learningEngine.addToHotCache(filePath, content);
+      }
+
+      const language = detectLanguage(filePath);
+      const lines = countLines(content);
+
+      // Track file view
+      this.learningEngine.trackEvent({ eventType: 'file_view', filePath });
+
+      // Track in feature context
+      this.featureContextManager.onFileOpened(filePath);
+
+      // Update Tier 1 with this as the active file
+      this.tier1.setActiveFile({
+        path: filePath,
+        content: getPreview(content, 2000),
+        language
+      });
+
+      return { content, language, lines };
+    } catch (error) {
+      console.error(`Error reading file ${filePath}:`, error);
+      return null;
+    }
+  }
+
+  getProjectSummary(): ProjectSummary {
+    const savedSummary = this.tier2.getProjectSummary();
+    const languages = this.tier2.getLanguages();
+    const totalFiles = this.tier2.getFileCount();
+    const totalLines = this.tier2.getTotalLines();
+    const recentDecisions = this.decisionTracker.getRecentDecisions(5);
+
+    // Try to detect dependencies from package.json or similar
+    const dependencies = this.detectDependencies();
+
+    return {
+      name: savedSummary?.name || basename(this.config.projectPath),
+      description: savedSummary?.description || 'No description available',
+      languages,
+      totalFiles,
+      totalLines,
+      keyDirectories: savedSummary?.keyDirectories || this.detectKeyDirectories(),
+      recentDecisions,
+      dependencies,
+      architectureNotes: savedSummary?.architectureNotes || ''
+    };
+  }
+
+  private updateProjectSummary(): void {
+    const languages = this.tier2.getLanguages();
+    const keyDirs = this.detectKeyDirectories();
+
+    this.tier2.updateProjectSummary(
+      basename(this.config.projectPath),
+      '',
+      languages,
+      keyDirs,
+      ''
+    );
+  }
+
+  // Phase 2: Auto-extract decisions from git commits and code comments
+  private async extractDecisions(): Promise<void> {
+    try {
+      const extractor = new DecisionExtractor(this.config.projectPath);
+      const extracted = await extractor.extractAll();
+
+      if (extracted.length === 0) {
+        return;
+      }
+
+      console.error(`Found ${extracted.length} potential decisions from git/comments`);
+
+      // Convert and store decisions (limit to avoid flooding)
+      const decisions = extractor.toDecisions(extracted.slice(0, 10));
+
+      for (const decision of decisions) {
+        // Check if we already have a similar decision
+        const existing = this.tier2.getRecentDecisions(50);
+        const isDuplicate = existing.some(d =>
+          d.title.toLowerCase() === decision.title.toLowerCase() ||
+          d.description.includes(decision.description.slice(0, 50))
+        );
+
+        if (!isDuplicate) {
+          // Generate embedding and store
+          const textToEmbed = `${decision.title}\n${decision.description}`;
+          const embedding = await this.indexer.getEmbeddingGenerator().embed(textToEmbed);
+          this.tier2.upsertDecision(decision, embedding);
+          this.tier1.addDecision(decision);
+        }
+      }
+
+      console.error('Decision extraction complete');
+    } catch (error) {
+      console.error('Error extracting decisions:', error);
+    }
+  }
+
+  private detectKeyDirectories(): string[] {
+    const commonDirs = ['src', 'lib', 'app', 'pages', 'components', 'api', 'server', 'client', 'core'];
+    const found: string[] = [];
+
+    for (const dir of commonDirs) {
+      if (existsSync(join(this.config.projectPath, dir))) {
+        found.push(dir);
+      }
+    }
+
+    return found;
+  }
+
+  private detectDependencies(): string[] {
+    const deps: string[] = [];
+
+    // Check package.json
+    const packageJsonPath = join(this.config.projectPath, 'package.json');
+    if (existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+        const allDeps = {
+          ...pkg.dependencies,
+          ...pkg.devDependencies
+        };
+        deps.push(...Object.keys(allDeps).slice(0, 20)); // Limit to 20
+      } catch {
+        // Ignore parse errors
+      }
+    }
+
+    // Check requirements.txt
+    const requirementsPath = join(this.config.projectPath, 'requirements.txt');
+    if (existsSync(requirementsPath)) {
+      try {
+        const content = readFileSync(requirementsPath, 'utf-8');
+        const lines = content.split('\n')
+          .map(l => l.trim())
+          .filter(l => l && !l.startsWith('#'))
+          .map(l => l.split(/[=<>]/)[0]?.trim())
+          .filter((l): l is string => !!l);
+        deps.push(...lines.slice(0, 20));
+      } catch {
+        // Ignore
+      }
+    }
+
+    return deps;
+  }
+
+  setCurrentGoal(goal: string): void {
+    this.tier1.setCurrentGoal(goal);
+  }
+
+  // Phase 2: Symbol search
+  async searchSymbols(name: string, kind?: string, limit: number = 10): Promise<CodeSymbol[]> {
+    return this.tier2.searchSymbols(name, kind as SymbolKind | undefined, limit);
+  }
+
+  // Phase 2: Get file dependencies
+  getFileDependencies(filePath: string): {
+    imports: Array<{ file: string; symbols: string[] }>;
+    importedBy: Array<{ file: string; symbols: string[] }>;
+    symbols: Array<{ name: string; kind: string; line: number; exported: boolean }>;
+  } {
+    const file = this.tier2.getFile(filePath);
+
+    if (!file) {
+      return { imports: [], importedBy: [], symbols: [] };
+    }
+
+    // Get what this file imports
+    const fileImports = this.tier2.getImportsByFile(file.id);
+    const imports = fileImports.map(i => ({
+      file: i.importedFrom,
+      symbols: i.importedSymbols
+    }));
+
+    // Get files that import this file
+    const dependents = this.tier2.getFileDependents(filePath);
+    const importedBy = dependents.map(d => ({
+      file: d.file,
+      symbols: d.imports
+    }));
+
+    // Get symbols defined in this file
+    const fileSymbols = this.tier2.getSymbolsByFile(file.id);
+    const symbols = fileSymbols.map(s => ({
+      name: s.name,
+      kind: s.kind,
+      line: s.lineStart,
+      exported: s.exported
+    }));
+
+    return { imports, importedBy, symbols };
+  }
+
+  // Phase 2: Get symbol count
+  getSymbolCount(): number {
+    return this.tier2.getSymbolCount();
+  }
+
+  // Phase 3: Get predicted files for pre-fetching
+  getPredictedFiles(currentFile: string, query: string): string[] {
+    return this.learningEngine.predictNeededFiles(currentFile, query);
+  }
+
+  // Phase 3: Pre-fetch predicted files into hot cache
+  async preFetchFiles(currentFile: string, query: string): Promise<number> {
+    const predicted = this.learningEngine.predictNeededFiles(currentFile, query);
+    let fetched = 0;
+
+    for (const filePath of predicted) {
+      if (!this.learningEngine.isInHotCache(filePath)) {
+        const absolutePath = join(this.config.projectPath, filePath);
+        if (existsSync(absolutePath)) {
+          try {
+            const content = readFileSync(absolutePath, 'utf-8');
+            this.learningEngine.addToHotCache(filePath, content);
+            fetched++;
+          } catch {
+            // Skip files that can't be read
+          }
+        }
+      }
+    }
+
+    return fetched;
+  }
+
+  // Phase 3: Get file summary (compressed representation)
+  getFileSummary(filePath: string): string | null {
+    const file = this.tier2.getFile(filePath);
+    if (!file) return null;
+
+    // Check if we have a cached summary
+    const cached = this.summarizer.getSummary(file.id);
+    if (cached && !this.summarizer.needsRegeneration(file.id, file.lastModified)) {
+      return cached.summary;
+    }
+
+    // Generate new summary
+    const symbols = this.tier2.getSymbolsByFile(file.id);
+    const imports = this.tier2.getImportsByFile(file.id);
+    const exports = this.tier2.getExportsByFile(file.id);
+
+    const summary = this.summarizer.generateSummary(
+      filePath,
+      file.preview,
+      symbols,
+      imports.map(i => ({ importedFrom: i.importedFrom, importedSymbols: i.importedSymbols })),
+      exports.map(e => ({ exportedName: e.exportedName }))
+    );
+
+    // Store for future use
+    this.summarizer.storeSummary(file.id, summary);
+
+    return summary;
+  }
+
+  // Phase 3: Get summaries for multiple files (for compressed context)
+  getFileSummaries(filePaths: string[]): Map<string, string> {
+    const result = new Map<string, string>();
+
+    for (const filePath of filePaths) {
+      const summary = this.getFileSummary(filePath);
+      if (summary) {
+        result.set(filePath, summary);
+      }
+    }
+
+    return result;
+  }
+
+  // Phase 3: Get learning/usage statistics
+  getLearningStats(): {
+    usageStats: ReturnType<LearningEngine['getUsageStats']>;
+    compressionStats: ReturnType<FileSummarizer['getCompressionStats']>;
+    hotCacheStats: ReturnType<LearningEngine['getHotCacheStats']>;
+  } {
+    return {
+      usageStats: this.learningEngine.getUsageStats(),
+      compressionStats: this.summarizer.getCompressionStats(),
+      hotCacheStats: this.learningEngine.getHotCacheStats()
+    };
+  }
+
+  // Phase 3: Mark context as useful/not useful for learning
+  markContextUsefulness(query: string, wasUseful: boolean): void {
+    this.learningEngine.updateQueryUsefulness(query, wasUseful);
+  }
+
+  // Phase 3: Get frequently accessed files
+  getFrequentFiles(limit: number = 20): string[] {
+    return this.learningEngine.getFrequentFiles(limit);
+  }
+
+  // Phase 3: Expand query for better search
+  expandQuery(query: string): string[] {
+    return this.learningEngine.expandQuery(query);
+  }
+
+  // ========== Phase 4: Multi-Project & Team Features ==========
+
+  // Get all registered projects
+  listProjects(): ProjectInfo[] {
+    return this.projectManager.listProjects();
+  }
+
+  // Get current active project
+  getActiveProject(): ProjectInfo | null {
+    return this.projectManager.getActiveProject();
+  }
+
+  // Get project by ID
+  getProject(projectId: string): ProjectInfo | null {
+    return this.projectManager.getProject(projectId);
+  }
+
+  // Switch to a different project
+  switchProject(projectId: string): boolean {
+    return this.projectManager.setActiveProject(projectId);
+  }
+
+  // Discover projects in common locations
+  discoverProjects(): string[] {
+    return this.projectManager.discoverProjects();
+  }
+
+  // Cross-project search - search across all registered projects
+  async searchAllProjects(query: string, limit: number = 10): Promise<Array<{
+    project: string;
+    projectId: string;
+    results: SearchResult[];
+  }>> {
+    const allResults: Array<{
+      project: string;
+      projectId: string;
+      results: SearchResult[];
+    }> = [];
+
+    const projectDbs = this.projectManager.getProjectDatabases();
+
+    try {
+      // Generate embedding for query
+      const embedding = await this.indexer.getEmbeddingGenerator().embed(query);
+
+      for (const { project, db } of projectDbs) {
+        try {
+          // Search each project's database
+          const tempTier2 = new Tier2Storage(db);
+          const results = tempTier2.search(embedding, limit);
+
+          if (results.length > 0) {
+            allResults.push({
+              project: project.name,
+              projectId: project.id,
+              results
+            });
+          }
+        } catch (err) {
+          console.error(`Error searching project ${project.name}:`, err);
+        }
+      }
+    } finally {
+      // Close all database connections
+      this.projectManager.closeAllDatabases(projectDbs);
+    }
+
+    // Sort by best match across projects
+    allResults.sort((a, b) => {
+      const maxA = Math.max(...a.results.map(r => r.similarity));
+      const maxB = Math.max(...b.results.map(r => r.similarity));
+      return maxB - maxA;
+    });
+
+    return allResults;
+  }
+
+  // Cross-project decision search
+  async searchAllDecisions(query: string, limit: number = 10): Promise<Array<{
+    project: string;
+    projectId: string;
+    decisions: Decision[];
+  }>> {
+    const allResults: Array<{
+      project: string;
+      projectId: string;
+      decisions: Decision[];
+    }> = [];
+
+    const projectDbs = this.projectManager.getProjectDatabases();
+
+    try {
+      // Generate embedding for query
+      const embedding = await this.indexer.getEmbeddingGenerator().embed(query);
+
+      for (const { project, db } of projectDbs) {
+        try {
+          const tempTier2 = new Tier2Storage(db);
+          const decisions = tempTier2.searchDecisions(embedding, limit);
+
+          if (decisions.length > 0) {
+            allResults.push({
+              project: project.name,
+              projectId: project.id,
+              decisions
+            });
+          }
+        } catch (err) {
+          console.error(`Error searching decisions in ${project.name}:`, err);
+        }
+      }
+    } finally {
+      this.projectManager.closeAllDatabases(projectDbs);
+    }
+
+    return allResults;
+  }
+
+  // Record decision with author attribution
+  async recordDecisionWithAuthor(
+    title: string,
+    description: string,
+    author: string,
+    files?: string[],
+    tags?: string[],
+    status: 'proposed' | 'accepted' | 'deprecated' | 'superseded' = 'accepted'
+  ): Promise<Decision> {
+    const decision: Decision = {
+      id: crypto.randomUUID(),
+      title,
+      description,
+      files: files || [],
+      tags: tags || [],
+      createdAt: new Date(),
+      author,
+      status
+    };
+
+    // Generate embedding
+    const textToEmbed = `${title}\n${description}`;
+    const embedding = await this.indexer.getEmbeddingGenerator().embed(textToEmbed);
+
+    // Store in tier2
+    this.tier2.upsertDecision(decision, embedding);
+
+    // Add to tier1 for recent decisions
+    this.tier1.addDecision(decision);
+
+    return decision;
+  }
+
+  // Update decision status
+  updateDecisionStatus(
+    decisionId: string,
+    status: 'proposed' | 'accepted' | 'deprecated' | 'superseded',
+    supersededBy?: string
+  ): boolean {
+    return this.tier2.updateDecisionStatus(decisionId, status, supersededBy);
+  }
+
+  // Get all decisions (for export)
+  getAllDecisions(): Decision[] {
+    return this.tier2.getAllDecisions();
+  }
+
+  // Export single decision to ADR file
+  exportDecisionToADR(decisionId: string, options?: ADRExportOptions): string | null {
+    const decisions = this.getAllDecisions();
+    const decision = decisions.find(d => d.id === decisionId);
+
+    if (!decision) {
+      return null;
+    }
+
+    return this.adrExporter.exportDecision(decision, options);
+  }
+
+  // Export all decisions to ADR files
+  exportAllDecisionsToADR(options?: ADRExportOptions): string[] {
+    const decisions = this.getAllDecisions();
+    return this.adrExporter.exportAllDecisions(decisions, options);
+  }
+
+  // Update project stats (called after indexing)
+  private updateProjectStats(): void {
+    const project = this.projectManager.getActiveProject();
+    if (project) {
+      this.projectManager.updateProjectStats(project.id, {
+        totalFiles: this.tier2.getFileCount(),
+        totalDecisions: this.getAllDecisions().length,
+        languages: this.tier2.getLanguages()
+      });
+    }
+  }
+
+  // ========== Phase 5: Active Feature Context ==========
+
+  // Get the hot context for current feature
+  getHotContext(): HotContext {
+    return this.featureContextManager.getHotContext();
+  }
+
+  // Get current active feature context
+  getActiveFeatureContext(): ActiveFeatureContext | null {
+    return this.featureContextManager.getCurrentContext();
+  }
+
+  // Get summary of current feature context
+  getActiveContextSummary(): { name: string; files: number; changes: number; duration: number } | null {
+    return this.featureContextManager.getCurrentSummary();
+  }
+
+  // Start a new feature context
+  startFeatureContext(name?: string): ActiveFeatureContext {
+    return this.featureContextManager.startNewContext(name);
+  }
+
+  // Set feature context name
+  setFeatureContextName(name: string): boolean {
+    return this.featureContextManager.setContextName(name);
+  }
+
+  // Get recent feature contexts
+  getRecentFeatureContexts(): ActiveFeatureContext[] {
+    return this.featureContextManager.getRecentContexts();
+  }
+
+  // Switch to a previous feature context
+  switchFeatureContext(contextId: string): boolean {
+    return this.featureContextManager.switchToRecent(contextId);
+  }
+
+  // Complete current feature context
+  completeFeatureContext(): boolean {
+    return this.featureContextManager.completeContext();
+  }
+
+  // Track a file being opened (for external triggers)
+  trackFileOpened(filePath: string): void {
+    this.featureContextManager.onFileOpened(filePath);
+  }
+
+  // Track a file being edited
+  trackFileEdited(filePath: string, diff: string, linesChanged?: number[]): void {
+    this.featureContextManager.onFileEdited(filePath, diff, linesChanged || []);
+  }
+
+  // Track a query with files used
+  trackQuery(query: string, filesUsed: string[]): void {
+    this.featureContextManager.onQuery(query, filesUsed);
+  }
+
+  // Get feature context manager for direct access
+  getFeatureContextManager(): FeatureContextManager {
+    return this.featureContextManager;
+  }
+
+  // ========== Phase 6: Living Documentation ==========
+
+  // Get project architecture overview
+  async getArchitecture(): Promise<ArchitectureDoc> {
+    return this.livingDocs.generateArchitectureDocs();
+  }
+
+  // Get detailed documentation for a component/file
+  async getComponentDoc(path: string): Promise<ComponentDoc> {
+    return this.livingDocs.generateComponentDoc(path);
+  }
+
+  // Get changelog of recent changes
+  async getChangelog(options?: ChangelogOptions): Promise<DailyChangelog[]> {
+    return this.livingDocs.generateChangelog(options || {});
+  }
+
+  // Validate documentation status
+  async validateDocs(): Promise<ValidationResult> {
+    return this.livingDocs.validateDocs();
+  }
+
+  // Query recent project activity
+  async whatHappened(since: string, scope?: string): Promise<ActivityResult> {
+    return this.livingDocs.whatHappened(since, scope);
+  }
+
+  // Find undocumented code
+  async findUndocumented(options?: {
+    importance?: 'low' | 'medium' | 'high' | 'all';
+    type?: 'file' | 'function' | 'class' | 'interface' | 'all';
+  }): Promise<UndocumentedItem[]> {
+    return this.livingDocs.findUndocumented(options);
+  }
+
+  // ========== Phase 7: Context Rot Prevention ==========
+
+  // Get context health status
+  getContextHealth(): ContextHealth {
+    return this.contextRotPrevention.getContextHealth();
+  }
+
+  // Set current token count (for external tracking)
+  setContextTokens(tokens: number): void {
+    this.contextRotPrevention.setCurrentTokens(tokens);
+  }
+
+  // Detect drift from initial requirements
+  detectDrift(): DriftResult {
+    return this.contextRotPrevention.detectDrift();
+  }
+
+  // Mark content as critical (never compress)
+  markCritical(
+    content: string,
+    options?: {
+      type?: CriticalContext['type'];
+      reason?: string;
+      source?: string;
+    }
+  ): CriticalContext {
+    return this.contextRotPrevention.markCritical(content, options);
+  }
+
+  // Get all critical context
+  getCriticalContext(type?: CriticalContext['type']): CriticalContext[] {
+    return this.contextRotPrevention.getCriticalContext(type);
+  }
+
+  // Remove a critical context item
+  removeCriticalContext(id: string): boolean {
+    return this.contextRotPrevention.removeCritical(id);
+  }
+
+  // Trigger context compaction
+  triggerCompaction(options: CompactionOptions): CompactionResult {
+    return this.contextRotPrevention.triggerCompaction(options);
+  }
+
+  // Auto-compact based on current health
+  autoCompact(): CompactionResult {
+    return this.contextRotPrevention.autoCompact();
+  }
+
+  // Add a message to conversation tracking
+  addConversationMessage(role: 'user' | 'assistant' | 'system', content: string): void {
+    this.contextRotPrevention.addMessage({ role, content });
+  }
+
+  // Clear conversation history
+  clearConversation(): void {
+    this.contextRotPrevention.clearConversation();
+  }
+
+  // Get context summary for AI (includes critical context and drift warnings)
+  getContextSummaryForAI(): string {
+    return this.contextRotPrevention.getContextSummaryForAI();
+  }
+
+  // ========== Phase 8: Confidence Scoring ==========
+
+  // Get confidence score for code
+  async getConfidence(code: string, context?: string): Promise<ConfidenceResult> {
+    return this.confidenceScorer.getConfidence(code, context);
+  }
+
+  // List sources for code suggestion
+  async listConfidenceSources(code: string, context?: string, includeSnippets?: boolean): Promise<ConfidenceSources> {
+    return this.confidenceScorer.listSources(code, context, includeSnippets);
+  }
+
+  // Check for conflicts with past decisions
+  async checkCodeConflicts(code: string): Promise<ConflictResult> {
+    return this.confidenceScorer.checkConflicts(code);
+  }
+
+  // Get confidence level indicator emoji
+  getConfidenceIndicator(level: ConfidenceLevel): string {
+    return ConfidenceScorer.getIndicator(level);
+  }
+
+  // Format confidence result for display
+  formatConfidenceResult(result: ConfidenceResult): string {
+    return ConfidenceScorer.formatResult(result);
+  }
+
+  // ========== Phase 9: Change Intelligence ==========
+
+  // Query what changed
+  whatChanged(options: ChangeQueryOptions = {}): ChangeQueryResult {
+    return this.changeIntelligence.whatChanged(options);
+  }
+
+  // Get changes for a specific file
+  whatChangedIn(file: string, limit?: number): Change[] {
+    return this.changeIntelligence.whatChangedIn(file, limit);
+  }
+
+  // Diagnose why something broke
+  whyBroke(error: string, options?: { file?: string; line?: number }): Diagnosis {
+    return this.changeIntelligence.whyBroke(error, options);
+  }
+
+  // Find similar bugs from history
+  findSimilarBugs(error: string, limit?: number): PastBug[] {
+    return this.changeIntelligence.findSimilarBugs(error, limit);
+  }
+
+  // Suggest fixes for an error
+  suggestFix(error: string, context?: string): FixSuggestion[] {
+    return this.changeIntelligence.suggestFix(error, context);
+  }
+
+  // Get recent changes
+  getRecentChanges(hours: number = 24): Change[] {
+    return this.changeIntelligence.getRecentChanges(hours);
+  }
+
+  // Format changes for display
+  formatChanges(result: ChangeQueryResult): string {
+    return ChangeIntelligence.formatChanges(result);
+  }
+
+  // Format diagnosis for display
+  formatDiagnosis(diagnosis: Diagnosis): string {
+    return ChangeIntelligence.formatDiagnosis(diagnosis);
+  }
+
+  // Format fix suggestions for display
+  formatFixSuggestions(suggestions: FixSuggestion[]): string {
+    return ChangeIntelligence.formatFixSuggestions(suggestions);
+  }
+
+  // ========== Phase 10: Architecture Enforcement ==========
+
+  // Validate code against patterns
+  validatePattern(code: string, type?: string): PatternValidationResult {
+    const category = type === 'auto' || !type ? undefined : type as PatternCategory;
+    return this.architectureEnforcement.validatePattern(code, category);
+  }
+
+  // Suggest existing functions for an intent
+  suggestExisting(intent: string, limit?: number): ExistingFunction[] {
+    return this.architectureEnforcement.suggestExisting(intent, limit);
+  }
+
+  // Learn a new pattern
+  learnPattern(
+    code: string,
+    name: string,
+    description?: string,
+    category?: string
+  ): { success: boolean; patternId?: string; message: string } {
+    return this.architectureEnforcement.learnPattern(
+      code,
+      name,
+      description,
+      category as PatternCategory | undefined
+    );
+  }
+
+  // List all patterns
+  listPatterns(category?: string): Pattern[] {
+    return this.architectureEnforcement.listPatterns(category as PatternCategory | undefined);
+  }
+
+  // Get a specific pattern
+  getPattern(id: string): Pattern | null {
+    return this.architectureEnforcement.getPattern(id);
+  }
+
+  // Add example to existing pattern
+  addPatternExample(
+    patternId: string,
+    code: string,
+    explanation: string,
+    isAntiPattern: boolean = false
+  ): boolean {
+    return this.architectureEnforcement.addExample(patternId, code, explanation, isAntiPattern);
+  }
+
+  // Add rule to existing pattern
+  addPatternRule(
+    patternId: string,
+    rule: string,
+    severity: 'info' | 'warning' | 'critical'
+  ): boolean {
+    return this.architectureEnforcement.addRule(patternId, rule, severity);
+  }
+
+  // Search patterns
+  searchPatterns(query: string): Pattern[] {
+    return this.architectureEnforcement.searchPatterns(query);
+  }
+
+  // Delete a pattern
+  deletePattern(id: string): boolean {
+    return this.architectureEnforcement.deletePattern(id);
+  }
+
+  // Get architecture statistics
+  getArchitectureStats(): {
+    patterns: {
+      total: number;
+      byCategory: Record<string, number>;
+      topPatterns: Array<{ name: string; usageCount: number }>;
+    };
+    functions: {
+      total: number;
+      exported: number;
+      byPurpose: Record<string, number>;
+    };
+  } {
+    return this.architectureEnforcement.getStats();
+  }
+
+  // Refresh the function index
+  refreshArchitectureIndex(): void {
+    this.architectureEnforcement.refreshIndex();
+  }
+
+  // Format validation result for display
+  formatValidationResult(result: PatternValidationResult): string {
+    return ArchitectureEnforcement.formatValidationResult(result);
+  }
+
+  // Format pattern list for display
+  formatPatternList(patterns: Pattern[]): string {
+    return ArchitectureEnforcement.formatPatternList(patterns);
+  }
+
+  // Format existing suggestions for display
+  formatExistingSuggestions(suggestions: ExistingFunction[]): string {
+    return ArchitectureEnforcement.formatSuggestions(suggestions);
+  }
+
+  // ========== Phase 11: Test-Aware Suggestions ==========
+
+  // Get tests related to a file or function
+  getRelatedTests(file: string, fn?: string): TestInfo[] {
+    return this.testAwareness.getRelatedTests(file, fn);
+  }
+
+  // Get tests for a specific file
+  getTestsForFile(file: string): TestInfo[] {
+    return this.testAwareness.getTestsForFile(file);
+  }
+
+  // Get all tests in the project
+  getAllTests(): TestInfo[] {
+    return this.testAwareness.getAllTests();
+  }
+
+  // Check if a code change would break tests
+  checkTests(code: string, file: string): TestValidationResult {
+    return this.testAwareness.checkTests(code, file);
+  }
+
+  // Suggest test updates for a change
+  suggestTestUpdate(change: string, failingTests?: string[]): TestUpdate[] {
+    return this.testAwareness.suggestTestUpdate(change, failingTests);
+  }
+
+  // Get test coverage for a file
+  getTestCoverage(file: string): TestCoverage {
+    return this.testAwareness.getCoverage(file);
+  }
+
+  // Get detected test framework
+  getTestFramework(): TestFramework {
+    return this.testAwareness.getFramework();
+  }
+
+  // Get total test count
+  getTestCount(): number {
+    return this.testAwareness.getTestCount();
+  }
+
+  // Generate test template for a function
+  generateTestTemplate(file: string, functionName: string): string {
+    return this.testAwareness.generateTestTemplate(file, functionName);
+  }
+
+  // Suggest new tests for uncovered functions
+  suggestNewTests(file: string): Array<{ function: string; template: string; priority: 'high' | 'medium' | 'low' }> {
+    return this.testAwareness.suggestNewTests(file);
+  }
+
+  // Refresh test index
+  refreshTestIndex(): { testsIndexed: number; framework: TestFramework } {
+    return this.testAwareness.refreshIndex();
+  }
+
+  // Format test validation result for display
+  formatTestValidationResult(result: TestValidationResult): string {
+    return this.testAwareness.formatValidationResult(result);
+  }
+
+  // Format test coverage for display
+  formatTestCoverage(coverage: TestCoverage): string {
+    return this.testAwareness.formatCoverage(coverage);
+  }
+
+  // Format test list for display
+  formatTestList(tests: TestInfo[]): string {
+    return this.testAwareness.formatTestList(tests);
+  }
+
+  // Format test updates for display
+  formatTestUpdates(updates: TestUpdate[]): string {
+    return this.testAwareness['testSuggester'].formatTestUpdates(updates);
+  }
+
+  // ========== Phase 12: Ghost Mode + Déjà Vu ==========
+
+  /**
+   * Get ghost insight - what the system knows about current work
+   */
+  getGhostInsight(): GhostInsight {
+    return this.ghostMode.getInsight();
+  }
+
+  /**
+   * Get ghost insight with conflict check for specific code
+   */
+  getGhostInsightForCode(code: string, targetFile?: string): GhostInsight {
+    return this.ghostMode.getInsightForCode(code, targetFile);
+  }
+
+  /**
+   * Check for conflicts with past decisions
+   */
+  checkGhostConflicts(code: string, targetFile?: string): ConflictWarning[] {
+    return this.ghostMode.checkConflicts(code, targetFile);
+  }
+
+  /**
+   * Notify ghost mode of file access (for silent tracking)
+   */
+  async notifyFileAccess(filePath: string): Promise<void> {
+    await this.ghostMode.onFileAccess(filePath);
+  }
+
+  /**
+   * Find similar past problems (déjà vu detection)
+   */
+  async findDejaVu(query: string, limit?: number): Promise<DejaVuMatch[]> {
+    return this.dejaVu.findSimilar(query, limit);
+  }
+
+  /**
+   * Record query for future déjà vu detection
+   */
+  recordQueryForDejaVu(query: string, files: string[], wasUseful?: boolean): void {
+    this.dejaVu.recordQuery(query, files, wasUseful);
+  }
+
+  /**
+   * Resurrect context from last session
+   * "Welcome back! Last time you were working on X, stuck on Y"
+   */
+  resurrectContext(options?: ContextResurrectionOptions): ResurrectedContext {
+    return this.featureContextManager.resurrectContext(options);
+  }
+
+  /**
+   * Get all contexts that can be resurrected
+   */
+  getResurrectableContexts(): Array<{ id: string; name: string; lastActive: Date; summary: string }> {
+    return this.featureContextManager.getResurrectableContexts();
+  }
+
+  /**
+   * Get comprehensive ghost mode data
+   * Combines ghost insight, déjà vu matches, and resurrection data
+   */
+  async getFullGhostData(
+    mode: 'full' | 'conflicts' | 'dejavu' | 'resurrect' = 'full',
+    options?: { code?: string; file?: string; query?: string }
+  ): Promise<{
+    ghost?: GhostInsight;
+    dejaVu?: DejaVuMatch[];
+    resurrection?: ResurrectedContext;
+    conflicts?: ConflictWarning[];
+  }> {
+    const result: {
+      ghost?: GhostInsight;
+      dejaVu?: DejaVuMatch[];
+      resurrection?: ResurrectedContext;
+      conflicts?: ConflictWarning[];
+    } = {};
+
+    if (mode === 'full' || mode === 'conflicts') {
+      if (options?.code) {
+        result.ghost = this.ghostMode.getInsightForCode(options.code, options.file);
+        result.conflicts = result.ghost.potentialConflicts;
+      } else {
+        result.ghost = this.ghostMode.getInsight();
+      }
+    }
+
+    if (mode === 'full' || mode === 'dejavu') {
+      if (options?.query || options?.code) {
+        result.dejaVu = await this.dejaVu.findSimilar(options.query || options.code || '', 5);
+      }
+    }
+
+    if (mode === 'full' || mode === 'resurrect') {
+      result.resurrection = this.featureContextManager.resurrectContext();
+    }
+
+    return result;
+  }
+
+  /**
+   * Get déjà vu statistics
+   */
+  getDejaVuStats(): { totalQueries: number; usefulQueries: number; avgUsefulness: number } {
+    return this.dejaVu.getStats();
+  }
+
+  // ========== Phase 13: Code Verification (Pre-Commit Quality Gate) ==========
+
+  /**
+   * Verify code for common AI-generated issues
+   * Catches: hallucinated imports, security vulnerabilities, dependency issues
+   */
+  async verifyCode(
+    code: string,
+    file?: string,
+    checks: VerificationCheck[] = ['all']
+  ): Promise<VerificationResult> {
+    return this.codeVerifier.verify(code, file, checks);
+  }
+
+  /**
+   * Quick security scan without full verification
+   */
+  quickSecurityScan(code: string, language?: string): SecurityScanResult {
+    return this.codeVerifier.scanSecurity(code, language);
+  }
+
+  /**
+   * Verify imports only
+   */
+  verifyImports(code: string, file?: string): ImportVerification {
+    return this.codeVerifier.verifyImports(code, file);
+  }
+
+  /**
+   * Check dependencies only
+   */
+  checkCodeDependencies(code: string): DependencyCheckResult {
+    return this.codeVerifier.checkDependencies(code);
+  }
+
+  shutdown(): void {
+    console.error('Shutting down MemoryLayer...');
+
+    // Stop background intelligence
+    if (this.backgroundInterval) {
+      clearInterval(this.backgroundInterval);
+      this.backgroundInterval = null;
+    }
+
+    this.indexer.stopWatching();
+    this.tier1.save();
+    this.featureContextManager.shutdown();
+    closeDatabase(this.db);
+  }
+}